perf(generator): optimize polymorphic deserialization with compile-time dispatch

Add optimal deserializers for polymorphic types in same-assembly scenarios:
- Generate DeserializePolymorphic and DeserializeRefPolymorphic methods
- Use switch-based dispatch on type IDs for known subtypes
- Add optimalDeserializer and optimalDeserializerRef parameters
- Support proper code indentation in generated methods
- Eliminate runtime type lookups for same-assembly polymorphic types

Mirrors serialization optimization from ee49724.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: JasonXuDeveloper

src/Nino.Core/NinoDeserializer.cs

@@ -145,6 +145,8 @@ public static class CachedDeserializer<T>
         private static int _typeId = -1;
         private static DeserializeDelegate<T> _deserializer;
         private static DeserializeDelegateRef<T> _deserializerRef;
+        private static DeserializeDelegate<T> _optimalDeserializer;
+        private static DeserializeDelegateRef<T> _optimalDeserializerRef;
         private static readonly FastMap<int, DeserializeDelegate<T>> SubTypeDeserializers = new();
         private static readonly FastMap<int, DeserializeDelegateRef<T>> SubTypeDeserializerRefs = new();
         private static int _singleSubTypeId = int.MinValue;
@@ -167,11 +169,14 @@ public static class CachedDeserializer<T>
         internal static readonly bool IsSimpleType = !IsReferenceOrContainsReferences && !HasBaseType;
 
         public static void SetDeserializer(int typeId, DeserializeDelegate<T> deserializer,
-            DeserializeDelegateRef<T> deserializerRef)
+            DeserializeDelegateRef<T> deserializerRef, DeserializeDelegate<T> optimalDeserializer,
+            DeserializeDelegateRef<T> optimalDeserializerRef)
         {
             _typeId = typeId;
             _deserializer = deserializer;
             _deserializerRef = deserializerRef;
+            _optimalDeserializer = optimalDeserializer;
+            _optimalDeserializerRef = optimalDeserializerRef;
             SubTypeDeserializers.Add(typeId, _deserializer);
             SubTypeDeserializerRefs.Add(typeId, _deserializerRef);
             _singleSubTypeId = int.MinValue;
@@ -278,18 +283,15 @@ public static void Deserialize(out T value, ref Reader reader)
                 return;
             }
 
-            // FAST PATH 2: JIT-eliminated branch for sealed types
-            // If T is sealed or a value type, it CANNOT have a different runtime type
-            // This completely eliminates polymorphic deserialization overhead
-            if (IsSealed || SubTypeDeserializers.Count == 1)
-            {
-                // DIRECT DELEGATE: Generated code path - no polymorphism possible
-                _deserializer(out value, ref reader);
-            }
-            else
+            // FAST PATH 1: Optimal serializer for polymorphic usage (with subtypes)
+            // This is a pre-generated serializer that handles polymorphism internally
+            if (_optimalDeserializer != null)
             {
-                DeserializePolymorphic(out value, ref reader);
+                _optimalDeserializer(out value, ref reader);
+                return;
             }
+
+            DeserializePolymorphic(out value, ref reader);
         }
 
         // ULTRA-OPTIMIZED: Single core ref method with all paths optimized
@@ -303,23 +305,30 @@ public static void DeserializeRef(ref T value, ref Reader reader)
                 return;
             }
 
+            // FAST PATH 1: Optimal serializer for polymorphic usage (with subtypes)
+            // This is a pre-generated serializer that handles polymorphism internally
+            if (_optimalDeserializerRef != null)
+            {
+                _optimalDeserializerRef(ref value, ref reader);
+                return;
+            }
+
+            DeserializeRefPolymorphic(ref value, ref reader);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void DeserializePolymorphic(out T value, ref Reader reader)
+        {
             // FAST PATH 2: JIT-eliminated branch for sealed types
             // If T is sealed or a value type, it CANNOT have a different runtime type
             // This completely eliminates polymorphic deserialization overhead
-            if (IsSealed || SubTypeDeserializerRefs.Count == 1)
+            if (IsSealed || SubTypeDeserializers.Count == 1)
             {
                 // DIRECT DELEGATE: Generated code path - no polymorphism possible
-                _deserializerRef(ref value, ref reader);
-            }
-            else
-            {
-                DeserializeRefPolymorphic(ref value, ref reader);
+                _deserializer(out value, ref reader);
+                return;
             }
-        }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void DeserializePolymorphic(out T value, ref Reader reader)
-        {
             // Peek type info for polymorphic types
             reader.Peak(out int typeId);
 
@@ -364,8 +373,18 @@ private static void DeserializePolymorphic(out T value, ref Reader reader)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void DeserializeRefPolymorphic(ref T value, ref Reader reader)
+        public static void DeserializeRefPolymorphic(ref T value, ref Reader reader)
         {
+            // FAST PATH 2: JIT-eliminated branch for sealed types
+            // If T is sealed or a value type, it CANNOT have a different runtime type
+            // This completely eliminates polymorphic deserialization overhead
+            if (IsSealed || SubTypeDeserializerRefs.Count == 1)
+            {
+                // DIRECT DELEGATE: Generated code path - no polymorphism possible
+                _deserializerRef(ref value, ref reader);
+                return;
+            }
+
             // Read type info first for polymorphic types
             reader.Peak(out int typeId);
 

src/Nino.Core/NinoTypeMetadata.cs

@@ -58,7 +58,10 @@ private static class SerializerRegistration<T>
         [EditorBrowsable(EditorBrowsableState.Never)]
         public static void RegisterDeserializer<T>(int typeId,
             DeserializeDelegate<T> deserializer,
-            DeserializeDelegateRef<T> deserializerRef, bool hasBaseType)
+            DeserializeDelegateRef<T> deserializerRef,
+            DeserializeDelegate<T> optimalDeserializer,
+            DeserializeDelegateRef<T> optimalDeserializerRef,
+            bool hasBaseType)
         {
             lock (DeserializerRegistration<T>.Lock)
             {
@@ -73,7 +76,7 @@ public static void RegisterDeserializer<T>(int typeId,
                         HasBaseTypeMap.Add(typeHandle, true);
                 }
 
-                CachedDeserializer<T>.SetDeserializer(typeId, deserializer, deserializerRef);
+                CachedDeserializer<T>.SetDeserializer(typeId, deserializer, deserializerRef, optimalDeserializer, optimalDeserializerRef);
                 (DeserializeDelegateBoxed outOverload,
                     DeserializeDelegateRefBoxed refOverload) pair = (CachedDeserializer<T>.DeserializeBoxed,
                         CachedDeserializer<T>.DeserializeBoxed);

src/Nino.Generator/BuiltInType/NinoBuiltInTypesGenerator.cs

@@ -111,7 +111,7 @@ protected override void Generate(SourceProductionContext spc)
             registrationCode.AppendLine(
                 $"                NinoTypeMetadata.RegisterSerializer<{typeName}>(Serializer.Serialize, Serializer.Serialize, false);");
             registrationCode.AppendLine(
-                $"                NinoTypeMetadata.RegisterDeserializer<{typeName}>(-1, Deserializer.Deserialize, Deserializer.DeserializeRef, false);");
+                $"                NinoTypeMetadata.RegisterDeserializer<{typeName}>(-1, Deserializer.Deserialize, Deserializer.DeserializeRef, Deserializer.Deserialize, Deserializer.DeserializeRef, false);");
         }
 
         var curNamespace = Compilation.AssemblyName!.GetNamespace();