Add VarHandle-based accessor generator for runtime mapper mode (#4194)

Introduces VarHandleAccessorGenerator, which generates PropertyAccessor
implementations using VarHandle (fields) and MethodHandle (method-based
properties) instead of delegating to __readXxx/__writeXxx synthetic methods.
This enables runtime-mode mapping without modifying entity bytecode on the
classpath, as required by CritterMapper (Phase 4).

- VarHandleAccessorGenerator: Gizmo-based generator using MethodHandles.privateLookupIn()
  to create VarHandle/MethodHandle fields in the constructor; entity class loaded
  via TCCL to avoid CritterClassLoader classloader mismatch
- PropertyFinder: runtimeMode flag skips entity bytecode registration and routes
  to VarHandleAccessorGenerator instead of PropertyAccessorGenerator
- CritterGizmoGenerator: runtimeMode param threaded through to PropertyFinder;
  varHandleAccessor() factory methods added
- TestVarHandleAccessor: covers String, int primitive, Long boxed fields;
  verifies entity class is not modified in runtime mode

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: evanchooly

critter/core/src/main/kotlin/dev/morphia/critter/parser/PropertyFinder.kt

@@ -5,6 +5,7 @@ import dev.morphia.critter.parser.gizmo.CritterGizmoGenerator.accessor
 import dev.morphia.critter.parser.gizmo.CritterGizmoGenerator.fieldAccessors
 import dev.morphia.critter.parser.gizmo.CritterGizmoGenerator.methodAccessors
 import dev.morphia.critter.parser.gizmo.CritterGizmoGenerator.propertyModelGenerator
+import dev.morphia.critter.parser.gizmo.CritterGizmoGenerator.varHandleAccessor
 import dev.morphia.critter.parser.gizmo.PropertyModelGenerator
 import dev.morphia.critter.parser.java.CritterParser
 import dev.morphia.mapping.Mapper
@@ -14,7 +15,11 @@ import org.objectweb.asm.tree.AnnotationNode
 import org.objectweb.asm.tree.ClassNode
 import org.objectweb.asm.tree.FieldNode
 
-class PropertyFinder(mapper: Mapper, val classLoader: CritterClassLoader) {
+class PropertyFinder(
+    mapper: Mapper,
+    val classLoader: CritterClassLoader,
+    val runtimeMode: Boolean = false,
+) {
     private val providerMap =
         mapper.config.propertyAnnotationProviders().associateBy { it.provides() }
 
@@ -23,15 +28,21 @@ class PropertyFinder(mapper: Mapper, val classLoader: CritterClassLoader) {
         val methods = discoverPropertyMethods(classNode)
         if (methods.isEmpty()) {
             val fields = discoverAllFields(entityType, classNode)
-            classLoader.register(entityType.name, fieldAccessors(entityType, fields))
+            if (!runtimeMode) {
+                classLoader.register(entityType.name, fieldAccessors(entityType, fields))
+            }
             fields.forEach { field ->
-                accessor(entityType, classLoader, field)
+                if (runtimeMode) varHandleAccessor(entityType, classLoader, field)
+                else accessor(entityType, classLoader, field)
                 models += propertyModelGenerator(entityType, classLoader, field)
             }
         } else {
-            classLoader.register(entityType.name, methodAccessors(entityType, methods))
+            if (!runtimeMode) {
+                classLoader.register(entityType.name, methodAccessors(entityType, methods))
+            }
             methods.forEach { method ->
-                accessor(entityType, classLoader, method)
+                if (runtimeMode) varHandleAccessor(entityType, classLoader, method)
+                else accessor(entityType, classLoader, method)
                 models += propertyModelGenerator(entityType, classLoader, method)
             }
         }

critter/core/src/main/kotlin/dev/morphia/critter/parser/gizmo/CritterGizmoGenerator.kt

@@ -14,14 +14,15 @@ object CritterGizmoGenerator {
     fun generate(
         type: Class<*>,
         critterClassLoader: CritterClassLoader = CritterClassLoader(),
+        runtimeMode: Boolean = false,
     ): GizmoEntityModelGenerator {
         val classNode = ClassNode()
         val resourceName = type.name.replace('.', '/') + ".class"
         val inputStream =
             type.classLoader.getResourceAsStream(resourceName)
                 ?: throw IllegalArgumentException("Could not find class file for ${type.name}")
         ClassReader(inputStream).accept(classNode, 0)
-        val propertyFinder = PropertyFinder(Generators.mapper, critterClassLoader)
+        val propertyFinder = PropertyFinder(Generators.mapper, critterClassLoader, runtimeMode)
 
         return entityModel(
             type,
@@ -43,6 +44,18 @@ object CritterGizmoGenerator {
     fun accessor(entityType: Class<*>, critterClassLoader: CritterClassLoader, method: MethodNode) =
         PropertyAccessorGenerator(entityType, critterClassLoader, method).emit()
 
+    fun varHandleAccessor(
+        entityType: Class<*>,
+        critterClassLoader: CritterClassLoader,
+        field: FieldNode,
+    ) = VarHandleAccessorGenerator(entityType, critterClassLoader, field).emit()
+
+    fun varHandleAccessor(
+        entityType: Class<*>,
+        critterClassLoader: CritterClassLoader,
+        method: MethodNode,
+    ) = VarHandleAccessorGenerator(entityType, critterClassLoader, method).emit()
+
     fun propertyModelGenerator(
         entityType: Class<*>,
         critterClassLoader: CritterClassLoader,