Prefer the exact type when resolving a member converter

GetMemberConverter walked the registrations and took the first whose type was
assignable from the declaring type, so a converter registered for a base type or
an interface permanently shadowed a more specific one that happened to be
registered later.

The exact declaring type is now looked up first, with the assignable walk as the
fallback, mirroring TryGetScrubOrIgnoreByMemberOfType.

Author: SimonCropp

src/StrictJsonTests/SerializationTests.MemberConverterExactType.verified.json

@@ -0,0 +1,8 @@
+{
+  "exact": {
+    "Value": "TheValue_Exact"
+  },
+  "inherited": {
+    "Value": "TheValue_Base"
+  }
+}

src/Verify.Tests/Serialization/SerializationTests.MemberConverterExactType.verified.txt

@@ -0,0 +1,8 @@
+{
+  exact: {
+    Value: TheValue_Exact
+  },
+  inherited: {
+    Value: TheValue_Base
+  }
+}

src/Verify.Tests/Serialization/SerializationTests.cs

@@ -4649,4 +4649,52 @@ Task SecondsFractionUpperShort() =>
                """)
             .ScrubInlineDateTimes("yyyy-MM-ddTHH:mm:ss.F");
 #endif
+
+    [ModuleInitializer]
+    public static void MemberConverterExactTypeInit()
+    {
+        // the interface is registered first, so without exact type precedence it wins
+        // for every implementation
+        VerifierSettings.MemberConverter<IMemberConverterBase, string>(
+            expression: _ => _.Value,
+            converter: _ => $"{_}_Base");
+
+        VerifierSettings.MemberConverter<MemberConverterExact, string>(
+            expression: _ => _.Value,
+            converter: _ => $"{_}_Exact");
+    }
+
+    [Fact]
+    public Task MemberConverterExactType() =>
+        Verify(
+            new
+            {
+                // the converter for the exact type wins
+                exact = new MemberConverterExact
+                {
+                    Value = "TheValue"
+                },
+                // and an implementation without one still falls back to the interface
+                inherited = new MemberConverterInherited
+                {
+                    Value = "TheValue"
+                }
+            });
+
+    interface IMemberConverterBase
+    {
+        string Value { get; set; }
+    }
+
+    class MemberConverterExact :
+        IMemberConverterBase
+    {
+        public string Value { get; set; }
+    }
+
+    class MemberConverterInherited :
+        IMemberConverterBase
+    {
+        public string Value { get; set; }
+    }
 }

src/Verify/Serialization/VerifierSettings_MemberConverter.cs

@@ -12,6 +12,19 @@ public static partial class VerifierSettings
 
     internal static ConvertTargetMember? GetMemberConverter(Type? declaringType, string name)
     {
+        if (declaringType is null)
+        {
+            return null;
+        }
+
+        // The exact type wins, so a converter registered for a base type or interface
+        // does not shadow a more specific one merely by being registered first
+        if (membersConverters.TryGetValue(declaringType, out var forType) &&
+            forType.TryGetValue(name, out var converter))
+        {
+            return converter;
+        }
+
         foreach (var pair in membersConverters)
         {
             if (pair.Key.IsAssignableFrom(declaringType) &&

src/todo.md

@@ -41,7 +41,7 @@ All six resolved 2026-08-16 (five fixed here; the inline item resolved as by-des
 - [ ] **Trimmed fraction format collapses into a standard format specifier.**
   `Verify/Serialization/Scrubbers/DateMatchers.cs:269-297` (consumed at 118-127) — `ScrubInlineDateTimes("s.F")` builds a secondary scrubber for `"s"`; length-1 formats are standard specifiers, so it scrubs every full sortable date-time in the output. `"H.F"` trims to `"H"` and throws `Invalid format: H` at registration despite passing up-front validation.
 
-- [ ] **`MemberConverter` has no exact-type precedence.**
+- [x] **`MemberConverter` has no exact-type precedence.**
   `Verify/Serialization/VerifierSettings_MemberConverter.cs:13-25` — first registered entry with `IsAssignableFrom` wins, so a base-interface converter registered earlier permanently shadows a more specific one. Contrast `TryGetScrubOrIgnoreByMemberOfType`, which checks the exact declaring type first.
 
 - [ ] **Registering an `IgnoreInstance` predicate disables empty-collection ignoring for that type.**