Refactor project structure and enhance functionality

Added `InternalsVisibleTo` attribute for "Ghost.Editor" in `AssemblyInfo.cs`.
Added a binary file `Empty.zip` to the project.
Added a new `ProjectMetadata` class in `ProjectMetadata.cs`.
Added new states and interfaces for managing application states in `EditorState.cs`, `LandingState.cs`, and `IAppState.cs`.
Added a notification service in `INotificationService.cs` and `StackedNotificationService.cs`.
Added new XAML files for UI components, including `InspectorView.xaml` and `InternalControls.xaml`.

Changed the `ProjectInfo` class in `ProjectInfo.cs` to include a `MetadataPath` property instead of `Path` and `EngineVersion`.
Changed the `TemplateInfo` class in `TemplateInfo.cs` to use a struct instead of a class for `TemplateData`.
Changed the `ProjectService` class to use the new `ProjectRepository` for managing project data.

Removed several using directives and the entire `ProjectRepository` class from `ProjectRepository.cs`, replacing it with a new implementation.
Removed old methods and properties in `EntityManager` and `World` classes to improve entity management and component handling.

Updated the `Ghost.Data.csproj` file to include the new `Empty.zip` file as a content item.
Updated the `ProjectRepository` class to manage project data using SQLite.
Updated various XAML files to include new styles and controls, improving the overall UI design.
Updated the `CreateProjectViewModel` to include a notification service and handle project creation logic.
Updated the test project to include references to the new `Ghost.Graphics` project and modified test cases to align with the new structure.

Ghost.Entities/System.cs

@@ -1,19 +1,30 @@
-namespace Ghost.Entities;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
 
 public abstract class SystemBase
 {
+    /// <summary>
+    /// Gets the execution order of the current operation or component.
+    /// </summary>
     public virtual int ExecutionOrder => 0;
 
+    /// <summary>
+    /// Gets or sets a value indicating whether the feature is enabled.
+    /// </summary>
     public virtual bool Enable
     {
         get;
         set;
     } = true;
 
+    /// <summary>
+    /// The world that this system belongs to.
+    /// </summary>
     public World World
     {
         get;
-        init;
+        internal set;
     } = null!;
 
     public virtual void OnCreate()
@@ -29,38 +40,73 @@ public abstract class SystemBase
     }
 }
 
-internal class SystemStorage : IDisposable
+public class SystemStorage : IDisposable
 {
     private readonly List<SystemBase> _systems = new();
     private readonly List<SystemBase> _executionList = new();
 
+    private readonly World _world;
+
+    public event Action<SystemBase>? SystemAdded;
+    public event Action<SystemBase>? SystemRemoved;
+
+    internal SystemStorage(World world)
+    {
+        _world = world;
+    }
+
     public void AddSystem<T>(T system)
         where T : SystemBase
     {
         _systems.Add(system);
+        system.World = _world;
         if (system.Enable)
         {
             system.OnCreate();
         }
+
+        SystemAdded?.Invoke(system);
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddSystem<T>()
+        where T : SystemBase, new()
+    {
+        AddSystem(new T());
     }
 
     public void RemoveSystem<T>(T system)
         where T : SystemBase
     {
+        system.World = null!;
         _systems.Remove(system);
         if (system.Enable)
         {
             system.OnDestroy();
         }
+
+        SystemRemoved?.Invoke(system);
     }
 
-    public void RebuildExecutionList()
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void RemoveSystem<T>()
+        where T : SystemBase, new()
+    {
+        var system = _systems.FirstOrDefault(s => s is T);
+        if (system != null)
+        {
+            RemoveSystem(system);
+        }
+    }
+
+    internal void RebuildExecutionList()
     {
         _executionList.Clear();
         _executionList.AddRange(_systems.OrderBy(s => s.ExecutionOrder));
     }
 
-    public void UpdateSystems()
+    internal void UpdateSystems()
     {
         foreach (var system in _systems)
         {