fix(test): order three more unsynchronized assertions behind the observables they follow

Deferred flake-pattern sweep of tests/ for the class fixed in c4caebe9 and
cfa6acbf — a bounded wait on observable A followed by a bare assert on an
observable B that the product only reaches strictly after A. Three clear
instances, each reproduced deterministically by delaying only the later step
and each re-verified green with that same delay still injected.

AlarmOnTriggerRuns_ShedAtTheSameCap_WithAnAlarmScopedSiteEvent gated on the
rate-limited shed site event and then asserted the shed COUNT bare.
AlarmActor.ShedAlarmRun increments the counter and only then emits the event,
and the event fires on the first shed only — so the gate observed Flap(4)'s
shed and ordered nothing with respect to Flap(5)'s, which is a separate
mailbox message with no observable of its own (an alarm on-trigger run has no
Ask caller to reply to, unlike ScriptActor.ShedRun, whose sibling test is
correctly ordered by its ScriptCallResult and is left alone). Deferring
Flap(5) by 2 s failed it with "Expected: 2 / Actual: 1". The count is now
ACCUMULATED across polls rather than re-read, because
SiteHealthCollector.CollectReport DRAINS the interval counters — a poll loop
that simply re-read it would consume the first shed and never reach 2.

EndToEnd_GrpcStubError_RowStays_Pending_NextTick_Succeeds gated on the
central row arriving and then asserted bare that the site SQLite row had left
Pending. SiteAuditTelemetryActor pushes via IngestAuditEventsAsync (which is
what writes the central row) and calls MarkForwardedAsync only after parsing
the ack. Delaying just that post-push step failed it with
"Assert.DoesNotContain() Failure: Filter matched in collection".

PreSnapshotBuffer_IsCapped_DropsOldest_AndCountsTheDrops gated on
"Count >= cap" and then asserted "Count == cap + 1" bare — a gate strictly
weaker than the assertion it guards, so it ordered nothing with respect to
the last event of a FlushBuffer loop that delivers one at a time. Parking
that loop after its 19,999th delivery failed it with
"Expected: 20001 / Actual: 20000".

Also hardens GrpcCentralTransportTests.WaitUntil, which returned silently on
timeout; today's single caller re-asserts immediately, so this only sharpens
the message rather than fixing a live flake.

Cleared with evidence, not guessed: SiteAlarmLiveCacheService's LingerStop
removes the site entry inside one lock, so IsLive and GetCurrentAlarms flip
atomically; and SiteReconciliationActor walks response.Gap with a sequential
foreach in which the asserted "Gone" log precedes the awaited "Good" row, the
inverse of this class.

Test-only; every ordering named above is correct as written.

tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/Grpc/DebugStreamBridgeActorTests.cs

@@ -964,18 +964,26 @@ public class DebugStreamBridgeActorTests : TestKit
             t.AddMilliseconds(-1));
         ctx.BridgeActor.Tell(snapshot);
 
-        AwaitCondition(() =>
+        // One awaited block, gated on the EXACT final count. This used to gate on
+        // "Count >= cap" and then assert "Count == cap + 1" bare — a gate strictly
+        // weaker than the assertion it guards, which therefore orders nothing with
+        // respect to the last event. FlushBuffer delivers the buffered events one
+        // by one via _onEvent inside a single loop, so the poll can legitimately
+        // observe the count crossing `cap` while the loop still has an event to
+        // go. Reproduced deterministically by parking that loop for 3 s after its
+        // 19,999th delivery: the bare form failed with "Expected: 20001 / Actual:
+        // 20000". The claims are unchanged — exactly the snapshot plus the capped
+        // retained events, with the newest survivor last.
+        AwaitAssert(() =>
         {
-            lock (ctx.ReceivedEvents) { return ctx.ReceivedEvents.Count >= cap; }
+            lock (ctx.ReceivedEvents)
+            {
+                // Snapshot + exactly the retained (capped) events, and the newest survived.
+                Assert.Equal(cap + 1, ctx.ReceivedEvents.Count);
+                var lastAttr = ctx.ReceivedEvents.OfType<AttributeValueChanged>().Last();
+                Assert.Equal($"Attr{cap + overflow - 1}", lastAttr.AttributeName);
+            }
         }, TimeSpan.FromSeconds(10));
-
-        lock (ctx.ReceivedEvents)
-        {
-            // Snapshot + exactly the retained (capped) events, and the newest survived.
-            Assert.Equal(cap + 1, ctx.ReceivedEvents.Count);
-            var lastAttr = ctx.ReceivedEvents.OfType<AttributeValueChanged>().Last();
-            Assert.Equal($"Attr{cap + overflow - 1}", lastAttr.AttributeName);
-        }
     }
 
     [Fact]