Acceso a clases no visibles con reflexión

Clase anidada - clase definida dentro de otra clase (incluye clases estáticas y no estáticas)
clase interna - clase anidada no estática (instancia de clase interna necesita instancia de clase externa para existir)

Clases no anidadas (nivel superior)

Basándonos en su pregunta, sabemos que el constructor al que desea acceder no es público. Así que su clase puede verse así (A la clase está en algún paquete diferente al nuestro)

package package1;

public class A {
    A(){
        System.out.println("this is non-public constructor");
    }
}

Para crear una instancia de esta clase necesitamos llegar al constructor que queremos invocar, y hacerla accesible. Cuando esté hecho podemos usar Constructor#newInstance(arguments) para crear una instancia.

Class<?> c = Class.forName("package1.A");
//full package name --------^^^^^^^^^^
//or simpler without Class.forName:
//Class<package1.A> c = package1.A.class;

//In our case we need to use
Constructor<?> constructor = c.getDeclaredConstructor();
//note: getConstructor() can return only public constructors
//so we needed to search for any Declared constructor

//now we need to make this constructor accessible
constructor.setAccessible(true);//ABRACADABRA!

Object o = constructor.newInstance();

Clases anidadas e internas

Si desea acceder a la clase anidada (estática y no estática) con Class.forName necesita usar la sintaxis:

Class<?> clazz = Class.forName("package1.Outer$Nested");

Outer$Nested dice que la clase Nested se declara dentro de la clase Outer. Las clases anidadas son muy similares a los métodos, tienen acceso a todos los miembros de su clase externa (incluidos los privados).

Pero necesitamos recordar que la instancia de la clase interna existe requiere la instancia de su clase externa. Normalmente los creamos a través de:

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

Así que como ves cada instancia de la clase Interna tiene alguna información sobre su clase externa (la referencia a esa instancia externa se almacena en el campo this$0, más información: ¿Qué significa si una variable tiene el nombre "this 0 0" en IntelliJ IDEA mientras se depura Java?)

Así que al crear una instancia de Inner clase con Constructor#newInstance() debe pasar como primer argumento la referencia a la instancia de la clase Outer (para simular el comportamiento outer.new Inner()).

Aquí hay un ejemplo.

En el envase 1

package package1;

public class Outer {
    class Inner{
        Inner(){
            System.out.println("non-public constructor of inner class");
        }
    }
}

En el envase 2

package package2;

import package1.Outer;
import java.lang.reflect.Constructor;

public class Test {
    public static void main(String[] args) throws Exception {

        Outer outerObject = new Outer();

        Class<?> innerClazz = Class.forName("package1.Outer$Inner");

        // constructor of inner class as first argument need instance of
        // Outer class, so we need to select such constructor
        Constructor<?> constructor = innerClazz.getDeclaredConstructor(Outer.class);

        //we need to make constructor accessible 
        constructor.setAccessible(true);

        //and pass instance of Outer class as first argument
        Object o = constructor.newInstance(outerObject);

        System.out.println("we created object of class: "+o.getClass().getName());

    }
}

Clases anidadas estáticas

Las instancias de clases anidadas estáticas no requieren instancia de clase externa (ya que son estáticas). Así que en su caso no necesitamos buscar constructor con Outer.class como primer argumento. Y no necesitamos pasar instancia de clase externa como primera argumento. En otras palabras, el código será el mismo que para la clase no anidada (de nivel superior) (tal vez excepto el hecho de que tendría que agregar $Nested sintaxis en Class.forName()).