refactor(format): inline custom-codec dispatch in row codecs (#3716)

## Why?

Simplify codegen and runtime codepath, net -1 frame stack depth, set
stage for future feature work

## What does this PR do?

Replace CustomTypeEncoderRegistry$Gen<N>, a per-registration
Janino-generated class whose static encode/decode/newCollection methods
the row codec called into, with one static final CustomCodec /
CustomCollectionFactory field per registered codec on the row codec
class itself. Fields are initialized at class load from
CustomTypeEncoderRegistry; encode/decode invoke the cached instance.
Per-call cost is one indirect call; the Janino compile-and-define cycle
on first registration is gone.

CustomTypeEncoderRegistry collapses to two ConcurrentHashMap lookups
plus a singleton handler view. findCodec / findCollectionFactory are
public so a row codec generated under a child classloader can reach
them.

Key the collection-factory codegen cache on (container, element) rather
than container alone, so two SortedSet-typed sibling fields with
different element types dispatch to their own factories.

## AI Contribution Checklist

- [x] Substantial AI assistance was used in this PR: `yes` / `no`

AI Usage Disclosure
- substantial_ai_assistance: yes
- scope: all
- affected_files_or_subsystems: Java row format
- ai_review: 👍 
- ai_review_artifacts:

> Nothing blocking. Net is a clear win: deletes ~165 lines of
Janino-generated dispatch infrastructure, removes a class-generation
step from cold-start registration, and folds in a real bug fix for
sibling collection fields with a focused test.
> LGTM with no requested changes. Cleanly deletes the per-registration
Janino dispatch class in favor of static-final field caches on the row
codec itself, and fixes the sibling-SortedSet cache-keying bug with a
targeted test. fory-format suite is green (108/108, 4 pre-existing
skips).
>  — Claude

> Overall
> Sound refactor and a meaningful simplification — a Janino
compile/define cycle per registration is removed in favor of one
monomorphic, JIT-friendly call site per codec field. The (beanType,
fieldType) key matches at both codegen-time discovery and runtime
lookup, and concurrency moves from coarse synchronized to
ConcurrentHashMap cleanly. Residual risks are minor: small
generated-class bloat if duplicate TypeRefs ever reach customEncode.
> I followed the Apache Fory AI review policy: review was performed by a
read-only subagent (no edits, commits, or pushes), with findings ordered
by severity, citing exact file/line locations, and including the
validation commands the author should run before merging.
>  — Claude (Opus 4.7)

- human_verification: ✔️ 
- provenance_license_confirmation: ✔️ 

## Does this PR introduce any user-facing change?

Internal API change only

## Benchmark

> - JMH numbers across both suites, n=15 per benchmark on each side:
every measurement is within error bars of equal. No regression.
> - Inlining graphs confirm: both versions fully inline the user's
encode/decode body into the generated row codec, both call sites fully
> monomorphic (5120/5120 type profile). Baseline has one extra frame
(Gen1::encode trampoline); HEAD goes straight from toRow to
> WrappedCodec::encode. Both collapse to the same machine code in steady
state.

> Verdict: no performance regression, and the inlining shape is what the
static-final + monomorphic-INVOKEINTERFACE model predicts. The "static →
virtual" concern doesn't materialize because the old static call was
itself a thin static trampoline around an identical interface call.

Co-authored-by: Claude (on behalf of Steven Schlansker) <stevenschlansker+claude@apache.org>

Author: stevenschlansker

java/fory-format/src/main/java/org/apache/fory/format/encoder/BaseBinaryEncoderBuilder.java

@@ -69,6 +69,7 @@
 import org.apache.fory.format.row.binary.writer.BinaryWriter;
 import org.apache.fory.format.type.CustomTypeEncoderRegistry;
 import org.apache.fory.format.type.CustomTypeHandler;
+import org.apache.fory.format.type.CustomTypeRegistration;
 import org.apache.fory.format.type.DataTypes;
 import org.apache.fory.format.type.Field;
 import org.apache.fory.format.type.Schema;
@@ -768,15 +769,18 @@ protected Expression newCollection(Expression arrayData, TypeRef<?> typeRef) {
     CustomCollectionFactory<?, ?> customFactory =
         customTypeHandler.findCollectionFactory(clazz, componentClass.getRawType());
     if (customFactory != null) {
+      Reference factoryRef = customCollectionFactoryFieldRef(clazz, componentClass.getRawType());
       collection =
-          new StaticInvoke(
-              customTypeHandler.getClass(),
-              "newCollection",
+          new Cast(
+              new Invoke(
+                  factoryRef,
+                  "newCollection",
+                  "newCollectionObject",
+                  TypeRef.of(Object.class),
+                  false,
+                  size),
               typeRef,
-              false,
-              new Expression.Null(typeRef, true),
-              new Expression.Null(componentClass, true),
-              size);
+              "newCollection");
     } else if (TypeRef.of(clazz).isSupertypeOf(TypeRef.of(ArrayList.class))) {
       collection = new NewInstance(TypeRef.of(ArrayList.class), size);
     } else if (TypeRef.of(clazz).isSupertypeOf(TypeRef.of(HashSet.class))) {
@@ -921,26 +925,69 @@ protected Expression deserializeForObject(Expression value, TypeRef<?> typeRef)
     return new Invoke(foryRef, "deserialize", typeRef, value);
   }
 
+  // Static fields the row codec calls into. Initialized once at class load from
+  // CustomTypeEncoderRegistry; encode/decode call sites invoke the cached instance.
+  private final Map<TypeRef<?>, Reference> customCodecFieldRefs = new HashMap<>();
+  private final Map<CustomTypeRegistration, Reference> customCollectionFactoryFieldRefs =
+      new HashMap<>();
+
+  private Reference customCodecFieldRef(TypeRef<?> fieldType) {
+    return customCodecFieldRefs.computeIfAbsent(
+        fieldType,
+        ft -> {
+          String name = ctx.newName("_customCodec");
+          Expression init =
+              new StaticInvoke(
+                  CustomTypeEncoderRegistry.class,
+                  "findCodec",
+                  "",
+                  TypeRef.of(CustomCodec.class),
+                  false,
+                  false,
+                  false,
+                  Literal.ofClass(beanType.getRawType()),
+                  Literal.ofClass(ft.getRawType()));
+          ctx.addField(true, true, ctx.type(CustomCodec.class), name, init);
+          return new Reference(name, TypeRef.of(CustomCodec.class));
+        });
+  }
+
+  private Reference customCollectionFactoryFieldRef(Class<?> collectionType, Class<?> elementType) {
+    return customCollectionFactoryFieldRefs.computeIfAbsent(
+        new CustomTypeRegistration(collectionType, elementType),
+        reg -> {
+          String name = ctx.newName("_customCollectionFactory");
+          Expression init =
+              new StaticInvoke(
+                  CustomTypeEncoderRegistry.class,
+                  "findCollectionFactory",
+                  "",
+                  TypeRef.of(CustomCollectionFactory.class),
+                  false,
+                  false,
+                  false,
+                  Literal.ofClass(reg.getBeanType()),
+                  Literal.ofClass(reg.getFieldType()));
+          ctx.addField(true, true, ctx.type(CustomCollectionFactory.class), name, init);
+          return new Reference(name, TypeRef.of(CustomCollectionFactory.class));
+        });
+  }
+
   protected Expression customEncode(Expression inputObject, TypeRef<?> rewrittenType) {
-    return new Expression.StaticInvoke(
-        customTypeHandler.getClass(),
-        "encode",
-        "rewrittenValue",
+    Reference codecRef = customCodecFieldRef(inputObject.type());
+    return new Cast(
+        new Invoke(
+            codecRef, "encode", "rewrittenObject", TypeRef.of(Object.class), true, inputObject),
         rewrittenType,
-        true,
-        new Expression.Null(beanType, true),
-        inputObject);
+        "rewrittenValue");
   }
 
   protected Expression customDecode(TypeRef<?> typeRef, final Expression deserializedValue) {
-    return new Expression.StaticInvoke(
-        customTypeHandler.getClass(),
-        "decode",
-        "decodedValue",
+    Reference codecRef = customCodecFieldRef(typeRef);
+    return new Cast(
+        new Invoke(
+            codecRef, "decode", "decodedObject", TypeRef.of(Object.class), true, deserializedValue),
         typeRef,
-        true,
-        new Expression.Null(beanType, true),
-        new Expression.Null(typeRef, true),
-        deserializedValue);
+        "decodedValue");
   }
 }