fix(sidecar+protocols): typed catches with discard on shutdown swallow paths (cs/empty-catch-block)

Six bare-or-typed-but-empty catch blocks across sidecar teardown
(SidecarHttpTransport, SidecarBowireProtocol, SidecarJsonRpcTransport
x2), gRPC send loop, and the SocketIO discovery probe. Each catches a
genuinely expected exit path (cancellation during dispose, dead old
transport, closed stdin on a reaped child process, caller-cancel on
the channel, abort during the 2s discovery delay) where propagating
would either crash Dispose or block recovery.

Converted bare 'catch { }' to typed 'catch (Exception ex)' and added a
discard '_ = ex' to give CodeQL a real statement plus a comment block
explaining why the swallow is intentional. Behaviour identical.

Author: thomas-stegemann

src/Kuestenlogik.Bowire.Protocol.Grpc/GrpcBowireChannel.cs

@@ -272,7 +272,11 @@ private async Task RunDuplexAsync(Method<byte[], byte[]> rawMethod)
                     await call.RequestStream.WriteAsync(msg);
                 await call.RequestStream.CompleteAsync();
             }
-            catch (OperationCanceledException) { }
+            catch (OperationCanceledException ex)
+            {
+                // Caller closed the channel -- expected exit path.
+                _ = ex;
+            }
         }, token);
 
         await foreach (var responseBytes in call.ResponseStream.ReadAllAsync(token))

src/Kuestenlogik.Bowire.Protocol.SocketIo/BowireSocketIoProtocol.cs

@@ -60,7 +60,13 @@ public async Task<List<BowireServiceInfo>> DiscoverAsync(
             client.OnAny((name, _) => { detectedEvents.Add(name); return Task.CompletedTask; });
 
             await client.ConnectAsync();
-            try { await Task.Delay(2000, ct); } catch (OperationCanceledException) { }
+            try { await Task.Delay(2000, ct); }
+            catch (OperationCanceledException ex)
+            {
+                // Discovery probe cut short -- we still want the
+                // disconnect call below, so swallow rather than throw.
+                _ = ex;
+            }
             await client.DisconnectAsync();
 
             if (!connected) return [];

src/Kuestenlogik.Bowire/Plugins/Sidecar/SidecarBowireProtocol.cs

@@ -249,7 +249,14 @@ internal async Task<ISidecarTransport> EnsureStartedAsync(CancellationToken ct)
             // If a previous run died, dispose it before respawning.
             if (_transport is not null)
             {
-                try { await _transport.DisposeAsync().ConfigureAwait(false); } catch { }
+                try { await _transport.DisposeAsync().ConfigureAwait(false); }
+                catch (Exception ex)
+                {
+                    // Old transport already dead -- disposal is best-
+                    // effort. We're about to spawn a fresh one anyway,
+                    // so a clean-up failure here doesn't block recovery.
+                    _ = ex;
+                }
                 _transport = null;
                 _initResult = null;
             }

src/Kuestenlogik.Bowire/Plugins/Sidecar/SidecarHttpTransport.cs

@@ -185,7 +185,14 @@ public async ValueTask DisposeAsync()
         await _lifetime.CancelAsync().ConfigureAwait(false);
         if (_sseLoop is not null)
         {
-            try { await _sseLoop.ConfigureAwait(false); } catch { }
+            try { await _sseLoop.ConfigureAwait(false); }
+            catch (Exception ex)
+            {
+                // Best-effort wait for the SSE loop to observe our
+                // cancellation; the loop is already torn down, so any
+                // exception (cancel, network reset, &c) is irrelevant.
+                _ = ex;
+            }
         }
         _lifetime.Dispose();
         _http.Dispose();

src/Kuestenlogik.Bowire/Plugins/Sidecar/SidecarJsonRpcTransport.cs

@@ -251,7 +251,13 @@ public async ValueTask DisposeAsync()
             catch { /* swallow — we're killing the process anyway */ }
 
             try { _process.StandardInput.Close(); }
-            catch { }
+            catch (Exception ex)
+            {
+                // Process may already be gone (stream closed, disposed,
+                // or kernel reaped it) -- stdin-close is just a polite
+                // EOF signal, not a correctness requirement.
+                _ = ex;
+            }
 
             try
             {
@@ -270,7 +276,14 @@ public async ValueTask DisposeAsync()
 
         if (_readLoop is not null)
         {
-            try { await _readLoop.ConfigureAwait(false); } catch { }
+            try { await _readLoop.ConfigureAwait(false); }
+            catch (Exception ex)
+            {
+                // Read loop normally exits cleanly when the process
+                // closes stdout; if it didn't (cancel race, pipe error),
+                // we're already in disposal so propagating doesn't help.
+                _ = ex;
+            }
         }
         _process.Dispose();
     }