perf(core): remove inline cache from polymorphic serialization

Remove inline cache layer for polymorphic type handling:

**Serialization:**
- Remove _cachedTypeHandle and _cachedSerializer inline cache
- Remove volatile cache reads/writes
- Simplify to direct FastMap lookup after base type check
- Reduces memory overhead and eliminates cache maintenance cost

**Deserialization:**
- Remove _cachedTypeIdOut/_cachedTypeIdRef and cached deserializers
- Remove volatile cache reads/writes
- Simplify to direct FastMap lookup after exact type match check
- Consistent with serialization path

**Rationale:**
- FastMap already provides O(1) lookup performance
- Inline cache added complexity and volatile overhead
- Most polymorphic usage has limited subtype variance
- FastMap lookup is fast enough for typical use cases
- Simpler code is easier to maintain and optimize

This simplification maintains performance while reducing code complexity
and eliminating the memory/synchronization overhead of the inline cache.

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

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

Author: JasonXuDeveloper

src/Nino.Core/NinoDeserializer.cs

@@ -164,11 +164,6 @@ public static class CachedDeserializer<T>
         private static readonly FastMap<int, DeserializeDelegateRef<T>> SubTypeDeserializerRefs = new();
 
         // Inline cache for polymorphic deserialization (separate caches for out/ref)
-        private static int _cachedTypeIdOut = -1;
-        private static DeserializeDelegate<T> _cachedDeserializer;
-        private static int _cachedTypeIdRef = -1;
-        private static DeserializeDelegateRef<T> _cachedDeserializerRef;
-
         // Cache expensive type checks
         private static readonly bool IsReferenceOrContainsReferences =
             RuntimeHelpers.IsReferenceOrContainsReferences<T>();
@@ -335,21 +330,10 @@ private static void DeserializePolymorphic(out T value, ref Reader reader)
                 return;
             }
 
-            // Fast path: inline cache hit (most common case for batched data)
-            int cachedId = Volatile.Read(ref _cachedTypeIdOut);
-            var cachedDeserializer = Volatile.Read(ref _cachedDeserializer);
-            if (typeId == cachedId && cachedDeserializer != null)
-            {
-                cachedDeserializer(out value, ref reader);
-                return;
-            }
-
             // Slow path: lookup and update cache
             // Handle subtype with single lookup
             if (SubTypeDeserializers.TryGetValue(typeId, out var subTypeDeserializer))
             {
-                Volatile.Write(ref _cachedTypeIdOut, typeId);
-                Volatile.Write(ref _cachedDeserializer, subTypeDeserializer);
                 subTypeDeserializer(out value, ref reader);
                 return;
             }
@@ -377,21 +361,10 @@ private static void DeserializeRefPolymorphic(ref T value, ref Reader reader)
                 return;
             }
 
-            // Fast path: inline cache hit (most common case for batched data)
-            int cachedId = Volatile.Read(ref _cachedTypeIdRef);
-            var cachedDeserializer = Volatile.Read(ref _cachedDeserializerRef);
-            if (typeId == cachedId && cachedDeserializer != null)
-            {
-                cachedDeserializer(ref value, ref reader);
-                return;
-            }
-
             // Slow path: lookup and update cache
             // Handle subtype deserialization
             if (SubTypeDeserializerRefs.TryGetValue(typeId, out var subTypeDeserializer))
             {
-                Volatile.Write(ref _cachedTypeIdRef, typeId);
-                Volatile.Write(ref _cachedDeserializerRef, subTypeDeserializer);
                 subTypeDeserializer(ref value, ref reader);
                 return;
             }

src/Nino.Core/NinoSerializer.cs

@@ -183,10 +183,6 @@ public static class CachedSerializer<T>
         public static SerializeDelegate<T> Serializer;
         public static readonly FastMap<IntPtr, SerializeDelegate<T>> SubTypeSerializers = new();
 
-        // Inline cache for polymorphic serialization
-        private static IntPtr _cachedTypeHandle;
-        private static SerializeDelegate<T> _cachedSerializer;
-
         // Cache expensive type checks
         internal static readonly bool IsReferenceOrContainsReferences =
             RuntimeHelpers.IsReferenceOrContainsReferences<T>();
@@ -288,29 +284,17 @@ private static unsafe void SerializePolymorphic(T val, ref Writer writer)
             IntPtr actualTypeHandle = val.GetType().TypeHandle.Value;
 #endif
 
-            // FAST PATH 1: Base type (common for non-polymorphic usage)
+            // FAST PATH: Base type (common for non-polymorphic usage)
             if (actualTypeHandle == TypeHandle)
             {
                 Serializer(val, ref writer);
                 return;
             }
-            
-            // FAST PATH 2: Inline cache hit (most common for homogeneous batches)
-            // Check this FIRST - single pointer comparison, very cheap
-            var cachedHandle = Volatile.Read(ref _cachedTypeHandle);
-            var cachedSerializer = Volatile.Read(ref _cachedSerializer);
-            if (actualTypeHandle == cachedHandle && cachedSerializer != null)
-            {
-                cachedSerializer(val, ref writer);
-                return;
-            }
 
             // SLOW PATH: Full lookup in subtype map
             // Handle subtype serialization
             if (SubTypeSerializers.TryGetValue(actualTypeHandle, out var subTypeSerializer))
             {
-                Volatile.Write(ref _cachedTypeHandle, actualTypeHandle);
-                Volatile.Write(ref _cachedSerializer, subTypeSerializer);
                 subTypeSerializer(val, ref writer);
                 return;
             }
@@ -319,4 +303,4 @@ private static unsafe void SerializePolymorphic(T val, ref Writer writer)
         }
     }
 #pragma warning restore CA1000
-}
+}