fix(commons): Flow graph orders executions by emission sequence, timestamps only within one clock (arch-review F5)

Central rows carry central's clock, site rows the site's, so the global
OccurredAtUtc sort let a 1-2 s skew float a whole site execution ahead of the
inbound row / RouteCall that started it, and pushed the trigger-cascade spawner
search onto its parentChain[0] fallback.

FlowGraphBuilder.Build now orders executions by the input index of their
earliest-given row and orders steps by timestamp only INSIDE one execution
(one clock), breaking ties by kind rank then input index. A folded outbound
node keeps its earliest-by-time row's identity, which need not be the row given
first, so its index is the minimum over the rows folded into it. The spawner
search uses position in the ordered list rather than a raw timestamp compare.
FlowDebugRunner.RunMethodAsync keeps the collector's emission order instead of
re-sorting; the value-change path keeps its OrderBy (all rows share one site
clock). Replay input arrives timestamp-sorted from the repository, so its order
is unchanged.

The DelmiaShaped test fixture is still shuffled within each execution (the
inside-one-execution timestamp rule is unchanged) but now lists the executions
in emission order, since that is what fixes their relative order.

Claude-Session: https://claude.ai/code/session_01NcMG6xXdsJbmD2wYAgkK29

tests/ZB.MOM.WW.ScadaBridge.ManagementService.Tests/FlowDebugRunnerTests.cs

@@ -124,6 +124,31 @@ public class FlowDebugRunnerTests
         Assert.Contains(_central, e => e.AsRow().Kind == AuditKind.RouteCall);
     }
 
+    [Fact]
+    public async Task RunMethod_SiteClockBehindCentral_StillReturnsTheSinkEventsInEmissionOrder()
+    {
+        // Arch-review F5: the site's rows carry the SITE clock. A site 2 s behind central used to
+        // re-sort ahead of the always-on central RouteCall row.
+        var method = new ApiMethod("M", "x") { Id = 6, TimeoutSeconds = 5 };
+        _apiRepo.GetApiMethodByIdAsync(6, Arg.Any<CancellationToken>()).Returns(method);
+        _locator.GetSiteIdForInstanceAsync("inst", Arg.Any<CancellationToken>()).Returns("site-a");
+        var child = Guid.NewGuid();
+        var siteRun = ScadaBridgeAuditEventFactory.Create(AuditChannel.ScriptTrace, AuditKind.ScriptRun, AuditStatus.Delivered,
+            occurredAtUtc: DateTime.UtcNow.AddSeconds(-2), executionId: child, target: "work");
+        _router.RouteToCallAsync("site-a", Arg.Any<RouteToCallRequest>(), Arg.Any<CancellationToken>())
+            .Returns(ci => new RouteToCallResponse(((RouteToCallRequest)ci[1]).CorrelationId, true, 7, null, DateTimeOffset.UtcNow, child, [siteRun]));
+        _executor.RegisterHandler("M", ctx => ctx.Route.To("inst").Call("work"));
+
+        var result = await Runner().RunMethodAsync(_services.BuildServiceProvider(),
+            new FlowDebugRunMethodCommand(6, null), Deployer, CancellationToken.None);
+
+        Assert.True(result.Completed, result.Error);
+        Assert.Equal(3, result.Events.Count);
+        Assert.Equal(AuditKind.InboundRequest, result.Events[0].AsRow().Kind);
+        Assert.Equal(AuditKind.RouteCall, result.Events[1].AsRow().Kind);
+        Assert.Same(siteRun, result.Events[2]);
+    }
+
     [Fact]
     public async Task RunMethod_UnknownMethod_IsNotFound()
     {