fix: satisfy new SonarAnalyzer 10.30 rules S8969 and S8949

SonarAnalyzer 10.30 adds S8969 (redundant null-forgiving operator) and
S8949 (missing cancellation token). With TreatWarningsAsErrors both break
the build.

- Drop null-forgiving operators the compiler already knows are redundant,
  mostly after Assert.NotNull.
- Swap `.Where(t => t is not null)` for `.OfType<Task>()` in the hosted
  services' StopAsync so the loop task is non-null by type instead of by
  assertion.
- Thread the service token through the workspace heal paths and the
  pairing expiry write, and swallow the resulting cancellation on
  shutdown.
- Pass CancellationToken.None explicitly to ConnectionSupervisor's gate
  waits: those run during teardown, after _shutdown is already cancelled.

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

Author: HandyS11

src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs

@@ -49,12 +49,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _pairedLoop, _triggeredLoop, _statusLoop, _reachabilityLoop, _observedLoop, _wipedLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -173,7 +173,9 @@ public async Task EnsureConnectionAsync(ulong guildId, Guid serverId, Cancellati
     /// <inheritdoc />
     public async Task StopAsync(ulong guildId, Guid serverId)
     {
-        await _gate.WaitAsync().ConfigureAwait(false);
+        // CancellationToken.None, not _shutdown.Token: teardown must still acquire the gate after
+        // StopAllAsync has already cancelled _shutdown, otherwise the connection is never stopped.
+        await _gate.WaitAsync(CancellationToken.None).ConfigureAwait(false);
         try
         {
             await StopConnectionAsync((guildId, serverId)).ConfigureAwait(false);
@@ -188,7 +190,8 @@ public async Task StopAsync(ulong guildId, Guid serverId)
     public async Task StopAllAsync()
     {
         await _shutdown.CancelAsync().ConfigureAwait(false);
-        await _gate.WaitAsync().ConfigureAwait(false);
+        // CancellationToken.None: _shutdown was just cancelled, so waiting on it would abandon shutdown.
+        await _gate.WaitAsync(CancellationToken.None).ConfigureAwait(false);
         try
         {
             foreach (var key in _connections.Keys.ToList())

src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs

@@ -60,12 +60,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _relayLoop, _rigLoop, _tickLoop, _disconnectLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Map/Hosting/InfoMapHostedService.cs

@@ -58,12 +58,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _statusLoop, _tickLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Map/Hosting/MapHostedService.cs

@@ -79,12 +79,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _markerLoop, _settingsLoop, _statusLoop, _tickLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Pairing/Supervisor/PairingSupervisor.cs

@@ -249,10 +249,11 @@ private async Task MarkExpiredAsync((ulong Guild, ulong Owner) key, Guid registr
         await using (expireScope.ConfigureAwait(false))
         {
             var store = expireScope.ServiceProvider.GetRequiredService<IFcmRegistrationStore>();
-            await store.SetStatusAsync(registrationId, FcmRegistrationStatus.Expired).ConfigureAwait(false);
+            await store.SetStatusAsync(registrationId, FcmRegistrationStatus.Expired, _shutdown.Token)
+                .ConfigureAwait(false);
         }
 
-        await notifier.NotifyCredentialsExpiredAsync(key.Guild, key.Owner).ConfigureAwait(false);
+        await notifier.NotifyCredentialsExpiredAsync(key.Guild, key.Owner, _shutdown.Token).ConfigureAwait(false);
     }
 
     private sealed class Handle : IAsyncDisposable

src/RustPlusBot.Features.StorageMonitors/Hosting/StorageMonitorsHostedService.cs

@@ -47,12 +47,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _pairedLoop, _triggeredLoop, _statusLoop, _reachabilityLoop, _wipedLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Switches/Hosting/SwitchesHostedService.cs

@@ -49,12 +49,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _pairedLoop, _stateLoop, _statusLoop, _deviceLoop, _reachabilityLoop, _wipedLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Wipes/Hosting/WipesHostedService.cs

@@ -39,12 +39,12 @@ public async Task StopAsync(CancellationToken cancellationToken)
         foreach (var loop in new[]
                  {
                      _statusLoop, _wipedLoop
-                 }.Where(t => t is not null))
+                 }.OfType<Task>())
         {
             try
             {
 #pragma warning disable VSTHRD003 // Our own loop tasks, joined on stop.
-                await loop!.ConfigureAwait(false);
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)

src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs

@@ -97,7 +97,7 @@ private Task OnReadyAsync()
         // Healing sweeps every provisioned guild's channels over REST; doing it inline blocks the
         // gateway task and stalls event dispatch, so offload it. Failures must be caught here —
         // nothing awaits this.
-        _ = Task.Run(HealProvisionedGuildsAsync);
+        _ = Task.Run(HealProvisionedGuildsAsync, _cts.Token);
         return Task.CompletedTask;
     }
 
@@ -110,12 +110,16 @@ private async Task HealProvisionedGuildsAsync()
             {
                 var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
                 var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                foreach (var guildId in await store.GetProvisionedGuildIdsAsync().ConfigureAwait(false))
+                foreach (var guildId in await store.GetProvisionedGuildIdsAsync(_cts.Token).ConfigureAwait(false))
                 {
-                    await reconciler.HealGuildAsync(guildId).ConfigureAwait(false);
+                    await reconciler.HealGuildAsync(guildId, _cts.Token).ConfigureAwait(false);
                 }
             }
         }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
         catch (Exception ex) // Broad catch is intentional: a faulting startup heal must not crash the host.
         {
             logger.LogError(ex, "Startup self-heal failed.");
@@ -135,9 +139,13 @@ private async Task OnChannelDestroyedAsync(SocketChannel channel)
             await using (scope.ConfigureAwait(false))
             {
                 var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
-                await reconciler.HealGuildAsync(guildChannel.Guild.Id).ConfigureAwait(false);
+                await reconciler.HealGuildAsync(guildChannel.Guild.Id, _cts.Token).ConfigureAwait(false);
             }
         }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
         catch (Exception ex) // Broad catch is intentional: a faulting self-heal must not crash the host.
         {
             logger.LogError(ex, "Self-heal failed for guild {GuildId}.", guildChannel.Guild.Id);