fix: use synchronous save on window close to prevent state loss

Window close handler used SafeFireAndForgetSave (Task.Run), which creates
a race: the process may exit before the thread-pool write completes,
silently losing window size/position/maximized state on next launch.

Changed to synchronous ConfigService.Save() which completes in <1ms for
the tiny (<2KB) config file. Also promoted Save() from private to public
and added it to IConfigService for this exact shutdown scenario.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JusterZhu

src/App.axaml.cs

@@ -54,7 +54,7 @@ public override void OnFrameworkInitializationCompleted()
             if (config.WindowMaximized)
                 mainWindow.WindowState = WindowState.Maximized;
 
-            // Save window state on close
+            // Save window state on close (synchronous to guarantee completion before exit)
             var configService = ConfigServiceSingleton.Instance;
             mainWindow.Closing += (_, _) =>
             {
@@ -69,8 +69,15 @@ public override void OnFrameworkInitializationCompleted()
                     config.WindowHeight = mainWindow.Height;
                 }
 
-                // Fire-and-forget save (exceptions logged to Trace, not lost)
-                ConfigService.SafeFireAndForgetSave(configService);
+                // Synchronous save: config is tiny (<2KB), completes in <1ms.
+                // Must NOT be fire-and-forget — the process exits after Close and
+                // a Task.Run might not complete in time.
+                try { configService.Save(); }
+                catch (Exception ex)
+                {
+                    System.Diagnostics.Trace.WriteLine(
+                        $"[GeneralUpdate.Tools] Config save on close failed: {ex.Message}");
+                }
             };
 
             desktop.MainWindow = mainWindow;

src/Configuration/ConfigService.cs

@@ -98,8 +98,12 @@ public void Load()
         }
     }
 
-    /// <summary>Synchronous save for internal use during Load().</summary>
-    private void Save()
+    /// <summary>
+    /// Synchronous save. Blocks the calling thread until the file is written.
+    /// Suitable for shutdown/flush scenarios where fire-and-forget would risk
+    /// the process exiting before the write completes.
+    /// </summary>
+    public void Save()
     {
         _saveLock.Wait();
         try

src/Configuration/IConfigService.cs

@@ -16,6 +16,9 @@ public interface IConfigService
     /// <summary>Load configuration from disk. Called once at startup.</summary>
     Task LoadAsync();
 
+    /// <summary>Persist current configuration to disk synchronously. Safe for shutdown.</summary>
+    void Save();
+
     /// <summary>Persist current configuration to disk (with automatic backup).</summary>
     Task SaveAsync();