Refactor object inference in JSON converter

Replaces switch on JsonTokenType with a recursive method using JsonElement.ValueKind for more robust and accurate type inference. This improves handling of nested objects and arrays, and unifies the logic for converting JSON values to .NET types.

Author: Fellmonkey

templates/dotnet/Package/Converters/ObjectToInferredTypesConverter.cs.twig

@@ -7,32 +7,60 @@ namespace {{ spec.title | caseUcfirst }}.Converters
 {
     public class ObjectToInferredTypesConverter : JsonConverter<object>
     {
-        public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            switch (reader.TokenType)
+            using (JsonDocument document = JsonDocument.ParseValue(ref reader))
             {
-                case JsonTokenType.True:
-                    return true;
-                case JsonTokenType.False:
-                    return false;
-                case JsonTokenType.Number:
-                    if (reader.TryGetInt64(out long l))
+                return ConvertElement(document.RootElement);
+            }
+        }
+
+        private object? ConvertElement(JsonElement element)
+        {
+            switch (element.ValueKind)
+            {
+                case JsonValueKind.Object:
+                    var dictionary = new Dictionary<string, object?>();
+                    foreach (var property in element.EnumerateObject())
                     {
-                        return l;
+                        dictionary[property.Name] = ConvertElement(property.Value);
+                    }
+                    return dictionary;
+
+                case JsonValueKind.Array:
+                    var list = new List<object?>();
+                    foreach (var item in element.EnumerateArray())
+                    {
+                        list.Add(ConvertElement(item));
                     }
-                    return reader.GetDouble();
-                case JsonTokenType.String:
-                    if (reader.TryGetDateTime(out DateTime datetime))
+                    return list;
+
+                case JsonValueKind.String:
+                    if (element.TryGetDateTime(out DateTime datetime))
                     {
                         return datetime;
                     }
-                    return reader.GetString()!;
-                case JsonTokenType.StartObject:
-                    return JsonSerializer.Deserialize<Dictionary<string, object>>(ref reader, options)!;
-                case JsonTokenType.StartArray:
-                    return JsonSerializer.Deserialize<object[]>(ref reader, options)!;
+                    return element.GetString();
+
+                case JsonValueKind.Number:
+                    if (element.TryGetInt64(out long l))
+                    {
+                        return l;
+                    }
+                    return element.GetDouble();
+
+                case JsonValueKind.True:
+                    return true;
+
+                case JsonValueKind.False:
+                    return false;
+
+                case JsonValueKind.Null:
+                case JsonValueKind.Undefined:
+                    return null;
+
                 default:
-                    return JsonDocument.ParseValue(ref reader).RootElement.Clone();
+                    throw new JsonException($"Unsupported JsonValueKind: {element.ValueKind}");
             }
         }