C#: Remove `ConvertVariantToManagedObject`

Its two usages were:

- The Array `ICollection.CopyTo` implementation.
  It's possible that this class shouldn't be implementing the
  non-generic `ICollection`, but this commit doesn't change that.
  The new implementation stores the elements as boxed `Variant` values.
- The `Variant.Obj` property.
  I'm not sure if this property's existence is justified, but for now
  I rewrote it as a simpler version of `ConvertVariantToManagedObject`.

modules/mono/glue/GodotSharp/GodotSharp/Core/Array.cs

@@ -418,8 +418,8 @@ namespace Godot.Collections
             {
                 for (int i = 0; i < count; i++)
                 {
-                    object obj = Marshaling.ConvertVariantToManagedObject(NativeValue.DangerousSelfRef.Elements[i]);
-                    array.SetValue(obj, index);
+                    object boxedVariant = Variant.CreateCopyingBorrowed(NativeValue.DangerousSelfRef.Elements[i]);
+                    array.SetValue(boxedVariant, index);
                     index++;
                 }
             }

modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/Marshaling.cs

@@ -584,111 +584,6 @@ namespace Godot.NativeInterop
             return false;
         }
 
-        public static unsafe object? ConvertVariantToManagedObject(in godot_variant p_var)
-        {
-            switch (p_var.Type)
-            {
-                case Variant.Type.Bool:
-                    return p_var.Bool.ToBool();
-                case Variant.Type.Int:
-                    return p_var.Int;
-                case Variant.Type.Float:
-                {
-#if REAL_T_IS_DOUBLE
-                    return p_var.Float;
-#else
-                    return (float)p_var.Float;
-#endif
-                }
-                case Variant.Type.String:
-                    return ConvertStringToManaged(p_var.String);
-                case Variant.Type.Vector2:
-                    return p_var.Vector2;
-                case Variant.Type.Vector2i:
-                    return p_var.Vector2i;
-                case Variant.Type.Rect2:
-                    return p_var.Rect2;
-                case Variant.Type.Rect2i:
-                    return p_var.Rect2i;
-                case Variant.Type.Vector3:
-                    return p_var.Vector3;
-                case Variant.Type.Vector3i:
-                    return p_var.Vector3i;
-                case Variant.Type.Transform2d:
-                    return *p_var.Transform2D;
-                case Variant.Type.Vector4:
-                    return p_var.Vector4;
-                case Variant.Type.Vector4i:
-                    return p_var.Vector4i;
-                case Variant.Type.Plane:
-                    return p_var.Plane;
-                case Variant.Type.Quaternion:
-                    return p_var.Quaternion;
-                case Variant.Type.Aabb:
-                    return *p_var.AABB;
-                case Variant.Type.Basis:
-                    return *p_var.Basis;
-                case Variant.Type.Transform3d:
-                    return *p_var.Transform3D;
-                case Variant.Type.Projection:
-                    return *p_var.Projection;
-                case Variant.Type.Color:
-                    return p_var.Color;
-                case Variant.Type.StringName:
-                {
-                    // The Variant owns the value, so we need to make a copy
-                    return StringName.CreateTakingOwnershipOfDisposableValue(
-                        NativeFuncs.godotsharp_string_name_new_copy(p_var.StringName));
-                }
-                case Variant.Type.NodePath:
-                {
-                    // The Variant owns the value, so we need to make a copy
-                    return NodePath.CreateTakingOwnershipOfDisposableValue(
-                        NativeFuncs.godotsharp_node_path_new_copy(p_var.NodePath));
-                }
-                case Variant.Type.Rid:
-                    return p_var.RID;
-                case Variant.Type.Object:
-                    return InteropUtils.UnmanagedGetManaged(p_var.Object);
-                case Variant.Type.Callable:
-                    return ConvertCallableToManaged(p_var.Callable);
-                case Variant.Type.Signal:
-                    return ConvertSignalToManaged(p_var.Signal);
-                case Variant.Type.Dictionary:
-                {
-                    // The Variant owns the value, so we need to make a copy
-                    return Collections.Dictionary.CreateTakingOwnershipOfDisposableValue(
-                        NativeFuncs.godotsharp_dictionary_new_copy(p_var.Dictionary));
-                }
-                case Variant.Type.Array:
-                {
-                    // The Variant owns the value, so we need to make a copy
-                    return Collections.Array.CreateTakingOwnershipOfDisposableValue(
-                        NativeFuncs.godotsharp_array_new_copy(p_var.Array));
-                }
-                case Variant.Type.PackedByteArray:
-                    return VariantUtils.ConvertAsPackedByteArrayToSystemArray(p_var);
-                case Variant.Type.PackedInt32Array:
-                    return VariantUtils.ConvertAsPackedInt32ArrayToSystemArray(p_var);
-                case Variant.Type.PackedInt64Array:
-                    return VariantUtils.ConvertAsPackedInt64ArrayToSystemArray(p_var);
-                case Variant.Type.PackedFloat32Array:
-                    return VariantUtils.ConvertAsPackedFloat32ArrayToSystemArray(p_var);
-                case Variant.Type.PackedFloat64Array:
-                    return VariantUtils.ConvertAsPackedFloat64ArrayToSystemArray(p_var);
-                case Variant.Type.PackedStringArray:
-                    return VariantUtils.ConvertAsPackedStringArrayToSystemArray(p_var);
-                case Variant.Type.PackedVector2Array:
-                    return VariantUtils.ConvertAsPackedVector2ArrayToSystemArray(p_var);
-                case Variant.Type.PackedVector3Array:
-                    return VariantUtils.ConvertAsPackedVector3ArrayToSystemArray(p_var);
-                case Variant.Type.PackedColorArray:
-                    return VariantUtils.ConvertAsPackedColorArrayToSystemArray(p_var);
-                default:
-                    return null;
-            }
-        }
-
         // String
 
         public static unsafe godot_string ConvertStringToNative(string? p_mono_string)

modules/mono/glue/GodotSharp/GodotSharp/Core/Variant.cs

@@ -109,16 +109,54 @@ public partial struct Variant : IDisposable
 
     public override string ToString() => AsString();
 
-    public object? Obj
-    {
-        get
+    public object? Obj =>
+        _obj ??= NativeVar.DangerousSelfRef.Type switch
         {
-            if (_obj == null)
-                _obj = Marshaling.ConvertVariantToManagedObject((godot_variant)NativeVar);
-
-            return _obj;
-        }
-    }
+            Type.Bool => AsBool(),
+            Type.Int => AsInt64(),
+#if REAL_T_IS_DOUBLE
+            Type.Float => AsDouble(),
+#else
+            Type.Float => AsSingle(),
+#endif
+            Type.String => AsString(),
+            Type.Vector2 => AsVector2(),
+            Type.Vector2i => AsVector2i(),
+            Type.Rect2 => AsRect2(),
+            Type.Rect2i => AsRect2i(),
+            Type.Vector3 => AsVector3(),
+            Type.Vector3i => AsVector3i(),
+            Type.Transform2d => AsTransform2D(),
+            Type.Vector4 => AsVector4(),
+            Type.Vector4i => AsVector4i(),
+            Type.Plane => AsPlane(),
+            Type.Quaternion => AsQuaternion(),
+            Type.Aabb => AsAABB(),
+            Type.Basis => AsBasis(),
+            Type.Transform3d => AsTransform3D(),
+            Type.Projection => AsProjection(),
+            Type.Color => AsColor(),
+            Type.StringName => AsStringName(),
+            Type.NodePath => AsNodePath(),
+            Type.Rid => AsRID(),
+            Type.Object => AsGodotObject(),
+            Type.Callable => AsCallable(),
+            Type.Signal => AsSignalInfo(),
+            Type.Dictionary => AsGodotDictionary(),
+            Type.Array => AsGodotArray(),
+            Type.PackedByteArray => AsByteArray(),
+            Type.PackedInt32Array => AsInt32Array(),
+            Type.PackedInt64Array => AsInt64Array(),
+            Type.PackedFloat32Array => AsFloat32Array(),
+            Type.PackedFloat64Array => AsFloat64Array(),
+            Type.PackedStringArray => AsStringArray(),
+            Type.PackedVector2Array => AsVector2Array(),
+            Type.PackedVector3Array => AsVector3Array(),
+            Type.PackedColorArray => AsColorArray(),
+            Type.Nil => null,
+            Type.Max or _ =>
+                throw new InvalidOperationException($"Invalid Variant type: {NativeVar.DangerousSelfRef.Type}"),
+        };
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Variant From<[MustBeVariant] T>(in T from) =>