fix: resolve code-review findings (locally verified)

Server-054/055/056, Contracts-020/021/022, Tests-036/038/039,
IntegrationTests-030/031/032 (+033 deferred to live rig),
Client.Dotnet-026/028/029 (+027 won't-fix), Client.Go-030..034,
Client.Python-032..036, Client.Rust-033..038.

Key fix: SessionEventDistributor orphaned a subscriber that registered after
the pump completed but before disposal (Server-056) -> register paths now
complete late registrants under _lifecycleLock; regression test added. The
racy dashboard-mirror gRPC test made deterministic (Tests-039).

Verified green locally: gateway Tests targeted classes (GatewaySession,
SessionEventDistributor, GatewayOptionsValidator, ProtobufContractRoundTrip,
GatewaySessionDashboardMirror) + dotnet/go/python/rust client suites.

src/ZB.MOM.WW.MxGateway.Tests/Gateway/Sessions/GatewaySessionTests.cs

@@ -545,6 +545,43 @@ public sealed class GatewaySessionTests
         Assert.False(session.IsDetachGraceExpired(clock.GetUtcNow()));
     }
 
+    /// <summary>
+    ///     Server-055 regression. A FAILED first attach (the distributor never registered a
+    ///     subscriber) must NOT enter the detach-grace window: the catch path's
+    ///     <c>DetachEventSubscriber</c> rolls the reserved slot back to 0 but must not stamp
+    ///     <c>DetachedAtUtc</c>, because the "last subscriber dropped" semantics only apply once
+    ///     a subscriber was successfully registered. A freshly-Ready session whose first attach
+    ///     failed must therefore stay out of grace and never become sweep-eligible on that basis.
+    /// </summary>
+    [Fact]
+    public async Task DetachGrace_FailedFirstAttach_DoesNotEnterGrace()
+    {
+        FakeTimeProvider clock = new(DateTimeOffset.UtcNow);
+        FakeWorkerClient workerClient = new();
+
+        // QueueCapacity = 0 makes the distributor constructor throw ArgumentOutOfRangeException
+        // inside StartDistributorAndRegister, so the very first AttachEventSubscriber fails after
+        // it reserved a slot — exercising the catch → DetachEventSubscriber rollback path.
+        await using GatewaySession session = CreateReadySessionWithDetachGrace(
+            workerClient,
+            clock,
+            detachGrace: TimeSpan.FromSeconds(30),
+            queueCapacity: 0);
+
+        Assert.ThrowsAny<ArgumentException>(
+            () => session.AttachEventSubscriber(maxSubscribers: 1));
+
+        // The reserved slot was rolled back, but no successful subscriber ever existed, so the
+        // session must NOT have entered detach-grace.
+        Assert.Equal(SessionState.Ready, session.State);
+        Assert.Equal(0, session.ActiveEventSubscriberCount);
+        Assert.Null(session.DetachedAtUtc);
+
+        // And it must never become detach-grace-eligible no matter how far the clock advances.
+        clock.Advance(TimeSpan.FromHours(1));
+        Assert.False(session.IsDetachGraceExpired(clock.GetUtcNow()));
+    }
+
     /// <summary>
     ///     Task 11. The gateway-owned internal dashboard subscriber must NOT keep a session out
     ///     of detach-grace: with only the dashboard mirror attached (and no external gRPC
@@ -618,7 +655,8 @@ public sealed class GatewaySessionTests
         IWorkerClient workerClient,
         TimeProvider timeProvider,
         TimeSpan detachGrace,
-        IDashboardEventBroadcaster? dashboardBroadcaster = null)
+        IDashboardEventBroadcaster? dashboardBroadcaster = null,
+        int queueCapacity = 8)
     {
         GatewaySession session = new(
             sessionId: "session-test-detach-grace",
@@ -636,7 +674,7 @@ public sealed class GatewaySessionTests
             openedAt: timeProvider.GetUtcNow(),
             eventStreaming: new SessionEventStreaming(
                 new MxAccessGrpcMapper(),
-                new EventOptions { QueueCapacity = 8 },
+                new EventOptions { QueueCapacity = queueCapacity },
                 NullLogger<SessionEventDistributor>.Instance,
                 timeProvider,
                 new GatewayMetrics(),