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/AssetHandle/AssetDatabase.cs

@@ -0,0 +1,83 @@
+using System.Diagnostics;
+using System.Reflection;
+
+namespace Ghost.Editor.AssetHandle;
+
+public static class AssetDatabase
+{
+    private static readonly Dictionary<string, Action<string>> _assetOpenHandlers = new(StringComparer.OrdinalIgnoreCase);
+    private static readonly Dictionary<string, Func<string, Task>> _asyncAssetOpenHandler = new(StringComparer.OrdinalIgnoreCase);
+
+    static AssetDatabase()
+    {
+        RegisterAssetHandles();
+    }
+
+    private static void RegisterAssetHandles()
+    {
+        var methods = AppDomain.CurrentDomain.GetAssemblies()
+            .SelectMany(a => a.GetTypes())
+            .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
+            .Where(m => m.GetCustomAttribute<AssetOpenHandlerAttribute>() != null &&
+                m.GetParameters().Length == 1 &&
+                m.GetParameters()[0].ParameterType == typeof(string));
+
+        foreach (var method in methods)
+        {
+            var attr = method.GetCustomAttribute<AssetOpenHandlerAttribute>()!;
+            var del = (Action<string>)Delegate.CreateDelegate(typeof(Action<string>), method);
+            foreach (var ext in attr.Extensions)
+            {
+                if (_assetOpenHandlers.ContainsKey(ext))
+                {
+                    throw new InvalidOperationException($"Duplicate handler for extension '{ext}'");
+                }
+
+                _assetOpenHandlers[ext] = del;
+            }
+        }
+
+        var asyncMethods = AppDomain.CurrentDomain.GetAssemblies()
+            .SelectMany(a => a.GetTypes())
+            .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
+            .Where(m => m.GetCustomAttribute<AsyncAssetOpenHandlerAttribute>() != null &&
+                m.GetParameters().Length == 1 &&
+                m.GetParameters()[0].ParameterType == typeof(string) &&
+                m.ReturnType == typeof(Task));
+
+        foreach (var method in asyncMethods)
+        {
+            var attr = method.GetCustomAttribute<AsyncAssetOpenHandlerAttribute>()!;
+            var del = (Func<string, Task>)Delegate.CreateDelegate(typeof(Func<string, Task>), method);
+            foreach (var ext in attr.Extensions)
+            {
+                if (_asyncAssetOpenHandler.ContainsKey(ext))
+                {
+                    throw new InvalidOperationException($"Duplicate async handler for extension '{ext}'");
+                }
+                _asyncAssetOpenHandler[ext] = del;
+            }
+        }
+    }
+
+    public static async ValueTask OpenAsset(string path)
+    {
+        var extension = Path.GetExtension(path);
+        if (_assetOpenHandlers.TryGetValue(extension, out var handler))
+        {
+            handler(path);
+        }
+        else if (_asyncAssetOpenHandler.TryGetValue(extension, out var asyncHandler))
+        {
+            await asyncHandler(path);
+        }
+        else
+        {
+            Process.Start(new ProcessStartInfo(path)
+            {
+                UseShellExecute = true
+            });
+        }
+
+    }
+}

Ghost.Editor/AssetHandle/AssetOpenHandlerAttribute .cs

@@ -0,0 +1,29 @@
+namespace Ghost.Editor.AssetHandle;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class AssetOpenHandlerAttribute : Attribute
+{
+    public string[] Extensions
+    {
+        get;
+    }
+
+    public AssetOpenHandlerAttribute(params string[] extensions)
+    {
+        Extensions = extensions.Select(e => e.StartsWith(".") ? e.ToLowerInvariant() : "." + e.ToLowerInvariant()).ToArray();
+    }
+}
+
+[AttributeUsage(AttributeTargets.Method)]
+public class AsyncAssetOpenHandlerAttribute : Attribute
+{
+    public string[] Extensions
+    {
+        get;
+    }
+
+    public AsyncAssetOpenHandlerAttribute(params string[] extensions)
+    {
+        Extensions = extensions.Select(e => e.StartsWith(".") ? e.ToLowerInvariant() : "." + e.ToLowerInvariant()).ToArray();
+    }
+}