Refactor application structure and add unit tests

Added:
- New `ProgressService` class for managing progress indicators.
- New `AssetDatabase`, `AssetOpenHandlerAttribute`, and `AsyncAssetOpenHandlerAttribute` classes for asset handling.
- `Ghost.UnitTest` project for unit testing with associated files and configurations.

Changed:
- `ActivationHandler` class to ensure correct handling of `LaunchActivatedEventArgs`.
- `App.xaml.cs` to register `INotificationService` and `IProgressService`, replacing `StackedNotificationService`.
- `OnLaunched` method in `App.xaml.cs` to correctly call `ActivationHandler.Handle(args)` and start the host.
- `INavigationAware` interface from internal to public for broader access.
- `EditorState.cs` to activate `EditorApplication` with the current service provider.
- Property names in `AssetItem` and `ExplorerItem` structs to `Name` and `FullName`.
- `NotificationService` class to implement `INotificationService` and refactor notification handling.
- `AssetPathToGlyphConverter` to handle file extensions consistently.
- Bindings in `ProjectPage.xaml` and `ProjectPage.xaml.cs` to use `FullName` instead of `Path`.
- `EngineEditorWindow` and `LandingWindow` classes to utilize new notification and progress services.
- `Logger` class to include a new method for logging errors with exceptions.

Updated:
- Manifest files and project files to reflect new structure and dependencies.
- Solution file `GhostEngine.sln` to include the new unit test project.
- Added several new test classes and methods in `UnitTests.cs`.

Ghost.Editor/SceneGraph/EditorWorldManager.cs

@@ -0,0 +1,53 @@
+using Ghost.Editor.Resources;
+using Ghost.Editor.Services.Contracts;
+using Ghost.Engine.Resources;
+using System.Text.Json;
+
+namespace Ghost.Editor.SceneGraph;
+
+public enum OpenWorldMode
+{
+    Single,
+    Additive,
+    AdditiveWithoutLoading
+}
+
+public static class EditorWorldManager
+{
+    // TODO: Use guid keys instead of string paths for better performance and uniqueness
+    private static readonly Dictionary<string, WorldNode> _loadedWorlds = new();
+    public static IEnumerable<WorldNode> LoadedWorlds => _loadedWorlds.Values;
+
+    public static event Action<WorldNode>? OnWorldLoaded;
+    public static event Action<WorldNode>? OnWorldUnloaded;
+
+    public static async Task LoadWorld(string worldPath)
+    {
+        if (_loadedWorlds.ContainsKey(worldPath)
+            || !File.Exists(worldPath)
+            || Path.GetExtension(worldPath) != FileExtensions.SCENE_FILE_EXTENSION)
+        {
+            return;
+        }
+
+        var progressService = EditorApplication.GetService<IProgressService>();
+        progressService.ShowIndeterminateProgress("Loading world...");
+
+        foreach (var world in _loadedWorlds)
+        {
+            world.Value.Unload();
+            OnWorldUnloaded?.Invoke(world.Value);
+        }
+
+        await using var readStream = new FileStream(worldPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        var deserializedScene = await JsonSerializer.DeserializeAsync<WorldNode>(readStream, StaticResource.defaultSerializerOptions) ?? throw new Exception("Deserialization failed.");
+
+        _loadedWorlds.Clear();
+
+        _loadedWorlds[worldPath] = deserializedScene;
+        await deserializedScene.LoadAsync();
+
+        progressService.HideProgress();
+        OnWorldLoaded?.Invoke(deserializedScene);
+    }
+}

Ghost.Editor/SceneGraph/WorldNode.cs

@@ -1,14 +1,16 @@
-using Ghost.Editor.Serializer;
+using Ghost.Editor.Contracts;
+using Ghost.Editor.Serializer;
 using Ghost.Engine.Components;
 using Ghost.Entities;
+using Microsoft.UI.Xaml;
 using System.Text.Json.Serialization;
 
 namespace Ghost.Editor.SceneGraph;
 
 [JsonConverter(typeof(WorldNodeSerializer))]
-public partial class WorldNode : SceneGraphNode
+public partial class WorldNode : SceneGraphNode, IEquatable<WorldNode>
 {
-    private readonly World _world;
+    private World _world;
     private Dictionary<Entity, EntityNode> _entityNodeLookup = new();
 
     public World World => _world;
@@ -73,7 +75,6 @@ public partial class WorldNode : SceneGraphNode
 
     private EntityNode BuildNodeRecursive(Entity entity, World world)
     {
-        // TODO: Node serialization.
         if (!_entityNodeLookup.TryGetValue(entity, out var node))
         {
             node = new EntityNode(entity, "New Entity");
@@ -105,8 +106,69 @@ public partial class WorldNode : SceneGraphNode
         }
     }
 
-    public void Load()
+    public Task LoadAsync()
     {
-        BuildGraph();
+        return Task.Run(BuildGraph);
+    }
+
+    public void Unload()
+    {
+        _world.Dispose();
+        _world = null!;
+
+        Children?.Clear();
+        _entityNodeLookup.Clear();
+    }
+
+    public override string ToString()
+    {
+        return $"WorldNode: {Name} (World ID: {_world.ID})";
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(_world, Name);
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is WorldNode other && Equals(other);
+    }
+
+    public bool Equals(WorldNode? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, other))
+        {
+            return true;
+        }
+
+        return _world.Equals(other._world) && Name == other.Name;
+    }
+
+    public static bool operator ==(WorldNode? left, WorldNode? right)
+    {
+        if (left is null)
+        {
+            return right is null;
+        }
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(WorldNode? left, WorldNode? right)
+    {
+        return !(left == right);
+    }
+}
+
+public partial class WorldNode : IInspectable
+{
+    public UIElement OnInspectorDraw()
+    {
+        throw new NotImplementedException();
     }
 }