fix(driver-galaxy): resolve Medium code-review finding (Driver.Galaxy-007)

Implement IAsyncDisposable on GalaxyDriver so async sub-component disposals
(EventPump, AlarmFeed, MxSession, MxClient, RepositoryClient) are awaited rather
than blocked on GetAwaiter().GetResult(). DisposeAsync is now the primary path;
Dispose() delegates to it for using-statement compatibility. Each async component's
shutdown is awaited individually with a best-effort catch so a single slow shutdown
cannot prevent the rest of the cleanup sequence from running.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Galaxy/GalaxyDriver.cs

@@ -26,7 +26,7 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy;
 ///     "GalaxyMxGateway" so both paths can be live simultaneously during parity testing.
 /// </remarks>
 public sealed class GalaxyDriver
-    : IDriver, ITagDiscovery, IReadable, IWritable, ISubscribable, IRediscoverable, IHostConnectivityProbe, IAlarmSource, IDisposable
+    : IDriver, ITagDiscovery, IReadable, IWritable, ISubscribable, IRediscoverable, IHostConnectivityProbe, IAlarmSource, IDisposable, IAsyncDisposable
 {
     private readonly string _driverInstanceId;
     private readonly GalaxyDriverOptions _options;
@@ -1050,39 +1050,73 @@ public sealed class GalaxyDriver
             new GatewayGalaxyHierarchySource(_ownedRepositoryClient), _options.MxAccess.ClientName);
     }
 
-    public void Dispose()
+    /// <summary>
+    ///     Asynchronous disposal. Prefer <c>await using</c> over <c>using</c> — the
+    ///     async path does not block the caller while awaiting EventPump / session /
+    ///     client shutdown (Driver.Galaxy-007: the sync path blocked on
+    ///     <c>GetAwaiter().GetResult()</c> for every async sub-component, risking a
+    ///     deadlock under thread-pool starvation).
+    /// </summary>
+    public async ValueTask DisposeAsync()
     {
         if (_disposed) return;
         _disposed = true;
 
-        // Order: stop deploy watcher, supervisor, probe watcher, pump, then sessions and
-        // clients. Each step is best-effort — disposal during a faulted state shouldn't
-        // throw and prevent the rest of the cleanup.
+        // Synchronous sub-components first — none of these block.
         try { _deployWatcher?.Dispose(); } catch (Exception ex) { _logger.LogWarning(ex, "DeployWatcher dispose failed"); }
         try { _supervisor?.Dispose(); } catch (Exception ex) { _logger.LogWarning(ex, "ReconnectSupervisor dispose failed"); }
         try { _probeWatcher?.Dispose(); } catch (Exception ex) { _logger.LogWarning(ex, "ProbeWatcher dispose failed"); }
         try { _transportForwarder?.Dispose(); } catch (Exception ex) { _logger.LogWarning(ex, "Transport forwarder dispose failed"); }
 
+        // Async sub-components: await each so we don't block a thread-pool thread
+        // on a slow shutdown (e.g. EventPump draining its channel, gRPC stream closing).
         EventPump? pump;
         lock (_pumpLock) { pump = _eventPump; _eventPump = null; }
-        pump?.DisposeAsync().AsTask().GetAwaiter().GetResult();
+        if (pump is not null)
+        {
+            try { await pump.DisposeAsync().ConfigureAwait(false); }
+            catch (Exception ex) { _logger.LogWarning(ex, "EventPump dispose failed"); }
+        }
 
         IGalaxyAlarmFeed? alarmFeed;
         lock (_alarmFeedLock) { alarmFeed = _alarmFeed; _alarmFeed = null; }
-        try { alarmFeed?.DisposeAsync().AsTask().GetAwaiter().GetResult(); }
-        catch (Exception ex) { _logger.LogWarning(ex, "Alarm feed dispose failed"); }
+        if (alarmFeed is not null)
+        {
+            try { await alarmFeed.DisposeAsync().ConfigureAwait(false); }
+            catch (Exception ex) { _logger.LogWarning(ex, "Alarm feed dispose failed"); }
+        }
 
-        _ownedMxSession?.DisposeAsync().AsTask().GetAwaiter().GetResult();
-        _ownedMxSession = null;
+        if (_ownedMxSession is not null)
+        {
+            try { await _ownedMxSession.DisposeAsync().ConfigureAwait(false); }
+            catch (Exception ex) { _logger.LogWarning(ex, "MxSession dispose failed"); }
+            _ownedMxSession = null;
+        }
 
-        _ownedMxClient?.DisposeAsync().AsTask().GetAwaiter().GetResult();
-        _ownedMxClient = null;
+        if (_ownedMxClient is not null)
+        {
+            try { await _ownedMxClient.DisposeAsync().ConfigureAwait(false); }
+            catch (Exception ex) { _logger.LogWarning(ex, "MxClient dispose failed"); }
+            _ownedMxClient = null;
+        }
+
+        if (_ownedRepositoryClient is not null)
+        {
+            try { await _ownedRepositoryClient.DisposeAsync().ConfigureAwait(false); }
+            catch (Exception ex) { _logger.LogWarning(ex, "RepositoryClient dispose failed"); }
+            _ownedRepositoryClient = null;
+        }
 
-        _ownedRepositoryClient?.DisposeAsync().AsTask().GetAwaiter().GetResult();
-        _ownedRepositoryClient = null;
         _hierarchySource = null;
     }
 
+    /// <summary>
+    ///     Synchronous disposal. Prefer <see cref="DisposeAsync"/> in async contexts —
+    ///     this path must block on every async sub-component shutdown. Provided for
+    ///     compatibility with <c>using</c> statements that cannot <c>await</c>.
+    /// </summary>
+    public void Dispose() => DisposeAsync().AsTask().GetAwaiter().GetResult();
+
     /// <summary>
     ///     Address-space builder wrapper that records each variable's
     ///     <see cref="DriverAttributeInfo.SecurityClass"/> into the supplied dictionary