Fix AOT critter model generation for entities incompatible with static analysis

Introduces pre-generation compatibility checks that skip AOT for entities
the ClassFile API can't handle from a non-<init> context:

- Final fields: putfield on final from injected methods throws IllegalAccessError
- Private inherited fields: child class can't reach parent's private field
- Array-typed fields: checkcast mismatch when Morphia passes Object[] at runtime
- No @id on any field: entity uses getter-based discovery; AOT FIELDS mode would
  produce a model without @id, breaking tests that run with propertyDiscovery=METHODS
- @id on a getter (method path): same problem — entity must be discovered at runtime

Skipped entities fall through to Tier 2 (runtime nestmate generation) or
Tier 3 (reflection), which already handle all these cases correctly.

Also:
- Fix critterPackage() inner-class naming collision: use full relative class name
  (replacing $ with _) so TestLazyIdOnly$ReferencedEntity and
  TestLazyIdOnlyIgnoreMissing$ReferencedEntity no longer map to the same package
- Fix CritterMapper.tryLoadPregenerated() to catch Throwable so LinkageError /
  IllegalAccessError from stale AOT classes falls back to runtime generation
- Clean __morphia dirs before regenerating to prevent stale model files

Author: evanchooly

core/src/main/java/dev/morphia/critter/Critter.java

@@ -24,7 +24,13 @@ public class Critter {
      * Returns the package name used for generated Critter classes for the given entity.
      */
     public static String critterPackage(Class<?> entity) {
-        return "%s.__morphia.%s".formatted(entity.getPackageName(), entity.getSimpleName().toLowerCase());
+        // Use the full class name relative to the package (replacing $ with _) so that
+        // inner classes with the same simple name in different outer classes don't collide.
+        String pkg = entity.getPackageName();
+        String relativeName = pkg.isEmpty()
+                ? entity.getName()
+                : entity.getName().substring(pkg.length() + 1);
+        return "%s.__morphia.%s".formatted(pkg, relativeName.replace('$', '_').toLowerCase());
     }
 
     /**

core/src/main/java/dev/morphia/critter/parser/PropertyFinder.java

@@ -69,6 +69,7 @@ public List<PropertyModelGenerator> find(Class<?> standinType, ClassModel classM
         if (methods.isEmpty()) {
             List<FieldInfo> fields = discoverAllFields(standinType, classModel);
             if (!runtimeMode) {
+                checkAotCompatibility(fields, targetType);
                 classLoader.register(targetType.getName(), critterGenerator.fieldAccessors(targetType, fields));
             }
             for (FieldInfo field : fields) {
@@ -81,6 +82,7 @@ public List<PropertyModelGenerator> find(Class<?> standinType, ClassModel classM
             }
         } else {
             if (!runtimeMode) {
+                checkAotMethodCompatibility(methods, targetType, classModel);
                 classLoader.register(targetType.getName(), critterGenerator.methodAccessors(targetType, methods));
             }
             for (MethodInfo method : methods) {
@@ -95,6 +97,69 @@ public List<PropertyModelGenerator> find(Class<?> standinType, ClassModel classM
         return models;
     }
 
+    private static final String ID_ANNOTATION_DESC = "Ldev/morphia/annotations/Id;";
+
+    private void checkAotCompatibility(List<FieldInfo> fields, Class<?> targetType) {
+        boolean hasIdOnField = false;
+        for (FieldInfo field : fields) {
+            int flags = field.access();
+            if ((flags & ClassFile.ACC_FINAL) != 0) {
+                throw new UnsupportedOperationException(
+                        "AOT skip: final field '" + field.name() + "' in " + targetType.getName());
+            }
+            if ((flags & ClassFile.ACC_PRIVATE) != 0 && field.declaringClass() != targetType) {
+                throw new UnsupportedOperationException(
+                        "AOT skip: private inherited field '" + field.name() + "' from "
+                                + field.declaringClass().getName() + " in " + targetType.getName());
+            }
+            if (field.desc().startsWith("[")) {
+                throw new UnsupportedOperationException(
+                        "AOT skip: array-typed field '" + field.name() + "' in " + targetType.getName());
+            }
+            if (field.visibleAnnotations() != null && field.visibleAnnotations().stream()
+                    .anyMatch(a -> ID_ANNOTATION_DESC.equals(a.classSymbol().descriptorString()))) {
+                hasIdOnField = true;
+            }
+        }
+        if (!hasIdOnField) {
+            // @Id not on any field — entity likely uses getter-based discovery; skip AOT
+            // so the runtime can pick the correct property discovery mode.
+            throw new UnsupportedOperationException(
+                    "AOT skip: no @Id on any field in " + targetType.getName()
+                            + "; entity requires runtime property discovery");
+        }
+    }
+
+    private void checkAotMethodCompatibility(List<MethodInfo> methods, Class<?> targetType,
+            ClassModel classModel) {
+        // If @Id is missing from the discovered methods, look for it on any getter in the hierarchy.
+        // If found there, the entity relies on METHODS discovery for @Id — skip AOT so the runtime
+        // can use the correct discovery mode.
+        boolean hasIdInMethods = methods.stream()
+                .anyMatch(m -> m.visibleAnnotations() != null && m.visibleAnnotations().stream()
+                        .anyMatch(a -> ID_ANNOTATION_DESC.equals(a.classSymbol().descriptorString())));
+        if (hasIdInMethods) {
+            return;
+        }
+        ClassModel current = classModel;
+        Class<?> cls = targetType;
+        while (cls != null && cls != Object.class) {
+            ClassModel model = current != null ? current : readClassModel(cls);
+            if (model != null) {
+                for (io.github.dmlloyd.classfile.MethodModel method : model.methods()) {
+                    if (visibleAnnotations(method).stream()
+                            .anyMatch(a -> ID_ANNOTATION_DESC.equals(a.classSymbol().descriptorString()))) {
+                        throw new UnsupportedOperationException(
+                                "AOT skip: @Id on getter in " + targetType.getName()
+                                        + "; entity requires runtime property discovery");
+                    }
+                }
+            }
+            cls = cls.getSuperclass();
+            current = null;
+        }
+    }
+
     private boolean isPropertyAnnotated(List<Annotation> annotations, boolean allowUnannotated) {
         List<Annotation> anns = annotations != null ? annotations : List.of();
         return allowUnannotated || anns.stream()
@@ -141,9 +206,10 @@ private List<FieldInfo> discoverFields(ClassModel classModel, Class<?> declaring
         List<FieldInfo> result = new ArrayList<>();
         for (FieldModel field : classModel.fields()) {
             List<Annotation> visible = visibleAnnotations(field);
-            boolean isTransient = (field.flags().flagsMask() & ClassFile.ACC_TRANSIENT) != 0
+            int flags = field.flags().flagsMask();
+            boolean isTransient = (flags & ClassFile.ACC_TRANSIENT) != 0
                     || visible.stream().map(a -> a.classSymbol().descriptorString()).anyMatch(transientDescs::contains);
-            boolean isStatic = (field.flags().flagsMask() & ClassFile.ACC_STATIC) != 0;
+            boolean isStatic = (flags & ClassFile.ACC_STATIC) != 0;
             if (!isTransient && !isStatic && isPropertyAnnotated(visible, true)) {
                 String sig = field.findAttribute(signature())
                         .map(a -> a.signature().stringValue())

core/src/main/java/dev/morphia/mapping/CritterMapper.java

@@ -154,7 +154,7 @@ private EntityModel tryLoadPregenerated(Class<?> type) {
             return (EntityModel) ctor.newInstance(this);
         } catch (ClassNotFoundException e) {
             return null;
-        } catch (Exception e) {
+        } catch (Throwable e) {
             LOG.warn("Failed to load pre-generated model for {}: {}", type.getName(), e.getMessage());
             return null;
         }

core/src/test/java/dev/morphia/critter/parser/generator/BytecodeDumpTest.java

@@ -40,7 +40,12 @@ public void dumpBytecodeAsText() throws Exception {
 
         for (Class<?> entity : ENTITIES) {
             CritterClassLoader loader = new CritterClassLoader();
-            new CritterGenerator(defaultMapper()).generate(entity, loader, false);
+            try {
+                new CritterGenerator(defaultMapper()).generate(entity, loader, false);
+            } catch (UnsupportedOperationException e) {
+                // Entity requires runtime discovery; skip AOT dump for it
+                continue;
+            }
 
             for (Map.Entry<String, byte[]> entry : loader.getTypeDefinitions().entrySet()) {
                 String className = entry.getKey();

critter/critter-maven/src/main/kotlin/dev/morphia/critter/maven/CritterTestMojo.kt

@@ -44,6 +44,12 @@ class CritterTestMojo : AbstractMojo() {
                 return
             }
 
+            // Remove stale generated files so skipped entities don't leave orphaned models.
+            testClassesDirectory
+                .walkTopDown()
+                .filter { it.isDirectory && it.name == "__morphia" }
+                .forEach { it.deleteRecursively() }
+
             CritterProcessor(
                     classesDirectory = testClassesDirectory,
                     outputDirectory = testClassesDirectory,