test: replace wall-clock sleeps used as synchronization — register row 40

Six sleeps across four test files stood in for an observable edge. Each preceded an
ABSENCE assertion (or "settled" before one), so they failed toward false-pass rather than
flake: the assertion could not distinguish "the mechanism ran and correctly stayed quiet"
from "the mechanism had not run yet".

ScriptDeadlineAtEnqueueTests (two sleeps, the worst offender)
  - :105 Thread.Sleep(2s) — now two explicit edges: the run must be observably QUEUED
    (scheduler.QueueDepth >= 1, never checked before), then the wait polls until the 1 s
    budget has elapsed, bailing early if the run leaves the queue, and asserts it is STILL
    queued afterwards. The test now proves the design claim it was named for — queue wait
    burns the run's budget — instead of assuming it.
  - :128 Thread.Sleep(2s) + Assert.Equal(0, DetachedThreadCount) — replaced by a positive
    control: a second script that genuinely wedges a worker, on the same scheduler, same
    1 s timeout + 1 s grace, armed strictly later. Its stuck report is the edge; once it
    lands, every watchdog armed at or before it has provably finished its grace delay. The
    absence is then asserted per script name, and the detach counter is pinned at 1 (the
    wedged run) rather than 0 — which a counter that never moves also satisfied.

DeploymentWarmThenGateTests (:117 plus two sibling Task.Delay(500) startup waits)
  - The manager calls SetInstanceCounts unconditionally when its startup config load
    completes, so a report counter on the test collector is the startup edge. The
    empty-site zero is now the manager's own observation instead of an untouched field.

SiteAlarmLiveCacheServiceTests (:195, :216)
  - Both sampled IsLive once after a fixed sleep. Now they poll continuously across three
    linger windows on a new teardown observable (the mock client counts subscription
    cancellations), so a stop at any instant inside the window is caught, and each closes
    with a positive control proving that counter moves.

DataConnectionActorTests (:435)
  - A Task.Delay(200) "settle" after an AwaitCondition on a connect counter. The counter
    only proves ConnectAsync was CALLED; the actor is still Connecting until it processes
    the piped result. Now waits for the Connected health publication that BecomeConnected
    emits, so the subscribe under test provably runs against Connected rather than being
    silently stashed. (The stash path keeps its own coverage in
    WP6_ConnectingState_StashesSubscribeRequests.)

Negative controls (product broken in the working tree, old vs new test compared):
  - Stuck-script watchdog disabled entirely: OLD test passed 2/2, NEW test failed. The
    whole watchdog could be deleted and the old assertions were satisfied.
  - Startup reporting a phantom instance count and taking longer than 500 ms: OLD passed
    2/2, NEW failed (expected 0, actual 1).
  - Linger cancellation disabled + the remaining-viewer guard dropped, so the stream is
    torn down under a live viewer while IsLive keeps reporting true:
    Resubscribe_Within_Linger OLD passed 2/2, NEW failed. (Last_Viewer_Leaving caught this
    particular break in the old form too, via a later assertion — its strengthening is the
    teardown observable and the positive control, not a false-pass fix.)
  - DataConnectionActorTests :435 has no false-pass demo: the sleep guarded no assertion
    there, and the change is determinism plus proving the claimed state.

Also fixes a latent race these timing changes exposed in
InstanceActorChildAttributeRaceTests: it resolved child actors single-shot immediately
after construction, but ResolveOne throws until the child's cell is published on the
parent AND the cell's Actor property stays null until the child's constructor has run on
its own mailbox thread. Neither is ordered against the test thread, so it failed both ways
under full-suite load (~1 run in 6 once the sleeps above stopped padding the schedule;
14/14 green on the unmodified tree, so it was latent, not new). Resolution now retries to
a bounded deadline; the assertion is unchanged.

Verification: SiteRuntime.Tests 8/8 green (605 tests), Communication.Tests 3/3 (717),
DataConnectionLayer.Tests 3/3 (319). Test-only change — no src/ modifications.

tests/ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests/Actors/DeploymentWarmThenGateTests.cs

@@ -65,6 +65,21 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
             new SiteRuntimeOptions(), NullLogger<DeploymentManagerActor>.Instance, null,
             healthCollector)));
 
+    /// <summary>
+    /// Register row 40: starts a Deployment Manager and blocks until it has PROVABLY finished
+    /// its startup config load, by waiting for its first instance-count report. Replaces a bare
+    /// <c>await Task.Delay(500)</c>, which merely hoped 500 ms was enough and — for the empty-site
+    /// assertion — could not tell "startup ran and found nothing" from "startup had not run yet".
+    /// </summary>
+    private (IActorRef Dm, DeployedCountCollector Health) CreateStartedDeploymentManager()
+    {
+        var health = new DeployedCountCollector();
+        var dm = CreateDeploymentManager(health);
+        AwaitCondition(() => health.ReportCount > 0, TimeSpan.FromSeconds(20),
+            TimeSpan.FromMilliseconds(25));
+        return (dm, health);
+    }
+
     /// <summary>
     /// Captures the deployed-instance count the Deployment Manager reports. The count is
     /// mutated only on the actor thread — <c>HandleDeploy</c> adds the instance name,
@@ -73,7 +88,20 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
     /// </summary>
     private sealed class DeployedCountCollector : ISiteHealthCollector
     {
+        private int _reports;
+
         public int LastDeployedCount { get; private set; }
+
+        /// <summary>
+        /// Register row 40: how many times the Deployment Manager has reported instance
+        /// counts. The manager calls <see cref="SetInstanceCounts"/> unconditionally the
+        /// moment its startup config load completes (<c>HandleStartupConfigsLoaded</c>) —
+        /// including for an empty site — so a non-zero value here is the explicit
+        /// observable edge for "startup has finished", replacing a wall-clock sleep.
+        /// Without it, <c>LastDeployedCount == 0</c> is satisfied by the field's initial
+        /// value and proves nothing about the manager having started at all.
+        /// </summary>
+        public int ReportCount => Volatile.Read(ref _reports);
         public void IncrementScriptError() { }
         public void IncrementAlarmError() { }
         public void IncrementDeadLetter() { }
@@ -86,7 +114,12 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
         public void UpdateConnectionEndpoint(string connectionName, string endpoint) { }
         public void UpdateTagQuality(string connectionName, int good, int bad, int uncertain) { }
         public void SetStoreAndForwardDepths(IReadOnlyDictionary<string, int> depths) { }
-        public void SetInstanceCounts(int deployed, int enabled, int disabled) => LastDeployedCount = deployed;
+        public void SetInstanceCounts(int deployed, int enabled, int disabled)
+        {
+            LastDeployedCount = deployed;
+            Interlocked.Increment(ref _reports);
+        }
+
         public void SetParkedMessageCount(int count) { }
         public void SetNodeHostname(string hostname) { }
         public void SetClusterNodes(IReadOnlyList<Commons.Messages.Health.NodeStatus> nodes) { }
@@ -112,9 +145,10 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
     [Fact]
     public async Task DeleteArrivingDuringTheCompileWarm_IsQueuedAndAppliedAfterTheDeploy()
     {
-        var health = new DeployedCountCollector();
-        var dm = CreateDeploymentManager(health);
-        await Task.Delay(500); // empty startup
+        // The startup load has demonstrably completed (it reported counts at least once), so
+        // the zero below is the manager's own observation of an empty site rather than an
+        // untouched field.
+        var (dm, health) = CreateStartedDeploymentManager();
         Assert.Equal(0, health.LastDeployedCount);
 
         var deployProbe = CreateTestProbe();
@@ -145,8 +179,7 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
     [Fact]
     public async Task SecondDeployDuringTheWarm_SupersedesTheFirst_AndAnswersItsDeployer()
     {
-        var dm = CreateDeploymentManager();
-        await Task.Delay(500);
+        var (dm, _) = CreateStartedDeploymentManager();
 
         var first = CreateTestProbe();
         var second = CreateTestProbe();
@@ -177,8 +210,7 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
     [Fact]
     public async Task DeploysForDifferentInstances_DoNotBlockEachOther()
     {
-        var dm = CreateDeploymentManager();
-        await Task.Delay(500);
+        var (dm, _) = CreateStartedDeploymentManager();
 
         var probeX = CreateTestProbe();
         var probeY = CreateTestProbe();