Add component editors and UI controls

Added the `HierarchyEditor` and `LocalToWorldEditor` classes to implement custom component editing functionality.
Added the `Vector3Field` control for 3D vector manipulation and its corresponding XAML definition.
Added the `ComponentDataView` and `ComponentObject` classes to manage component data display and access.
Added the `CustomEditorAttribute` to mark classes as custom editors for specific components.

Changed the `IInspectable` interface to use properties for `Icon`, `HeaderContent`, and `InspectorContent`.
Changed the `PropertyField` class to enhance UI control binding capabilities.
Changed the `EditorWorldManager` to improve world data loading and deserialization processes.
Changed the `EntityNode` and `WorldNode` classes to update entity construction and component querying.
Changed the `StaticResource` class to include new binding flags for component properties.
Changed the `InspectorService` to remove old contract references and adopt new interfaces.
Changed the `QueryEnumerable` and related files to update generic constraints for improved type safety.
Changed the `QueryItem` class to reflect new generic constraints and enhance deconstruction.
Changed the `World.Query` methods to utilize the updated generic constraints.

Updated the `SerializationTest` to align with new entity creation and management practices.

Ghost.App/Utilities/Converters/Vector3ToQuaternionConverter.cs

@@ -0,0 +1,27 @@
+using Ghost.Engine.Utilities;
+using Microsoft.UI.Xaml.Data;
+using System.Numerics;
+
+namespace Ghost.Editor.Utilities.Converters;
+
+public partial class Vector3ToQuaternionConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, string language)
+    {
+        if (value is Vector3 vector)
+        {
+            return Quaternion.CreateFromYawPitchRoll(vector.Y, vector.X, vector.Z);
+        }
+
+        throw new ArgumentException("Value must be of type System.Numerics.Vector3.", nameof(value));
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, string language)
+    {
+        if (value is Quaternion quaternion)
+        {
+            return VectorUtility.CreateFromQuaternion(quaternion);
+        }
+        throw new ArgumentException("Value must be of type System.Numerics.Quaternion.", nameof(value));
+    }
+}

Ghost.App/Utilities/ReflectionBinding.cs

@@ -0,0 +1,46 @@
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System.Reflection;
+
+namespace Ghost.Editor.Utilities;
+
+public class ReflectionBinding
+{
+    private void RefreshField(FieldInfo field, FrameworkElement control, object source)
+    {
+        var value = field.GetValue(source);
+
+        switch (control)
+        {
+            case TextBox tb:
+                tb.Text = value?.ToString();
+                break;
+            case NumberBox nb when value is double d:
+                nb.Value = d;
+                break;
+                // Add more controls...
+        }
+    }
+
+    public void StartPollingField(FieldInfo field, FrameworkElement control, object component)
+    {
+        var lastValue = field.GetValue(component);
+
+        DispatcherTimer timer = new()
+        {
+            Interval = TimeSpan.FromMilliseconds(200)
+        };
+
+        timer.Tick += (_, _) =>
+        {
+            var currentValue = field.GetValue(component);
+            if (!Equals(currentValue, lastValue))
+            {
+                RefreshField(field, control, component);
+                lastValue = currentValue;
+            }
+        };
+
+        timer.Start();
+    }
+}

Ghost.App/Utilities/TypeCache.cs

@@ -1,9 +1,25 @@
 using Ghost.Entities;
-using System;
-using System.Linq;
+using System.Reflection;
 
 namespace Ghost.Editor.Utilities;
 
+public static class TypeCache
+{
+    private static readonly TypeInfo[] _types;
+
+    static TypeCache()
+    {
+        _types = AppDomain.CurrentDomain.GetAssemblies()
+            .SelectMany(assembly => assembly.DefinedTypes)
+            .ToArray();
+    }
+
+    public static Type[] GetTypes()
+    {
+        return _types;
+    }
+}
+
 public static class ComponentTypeCache
 {
     private static readonly Type?[][] _componentTypes;