fix(selftest): drain dispatcher after UpdateLayout in Harness.Render

Local 10x sweeps of the SelfTests suite flake at ~60% (6/10 runs failed),
clustered in NativeDocking_* fixtures whose pane bodies are hosted in a
TabView. The same suite is stable on CI.

Root cause: Harness.Render() did `WaitForIdleAsync() → UpdateLayout() →
Task.Delay(16)`. When Reactor reports idle, WaitForIdleAsync short-circuits
without pumping the dispatcher (the comment at ReactorHost.cs:910 already
flags this: "Returning early here is the classic flake source"). That left
16ms wall-clock as the only safety net for WinUI work that UpdateLayout()
itself scheduled — notably TabView's lazy ContentPresenter realization for
the selected tab, posted at Normal priority.

CI dispatchers run with steady load → 16ms always covered it. Local boxes
(IDE, file watchers, AV) introduced enough jitter that the post-Render
visual-tree probe occasionally lost the race. Failure signature was the
selected pane body / Memo subtree returning null from FindText, which then
cascaded across every assertion in the affected fixture.

Fix: yield once at Low priority between two UpdateLayout() calls. The
first layout schedules content-realization onto the dispatcher; the Low
yield drains it (guaranteed, not timing-dependent); the second layout
arranges the just-realized content. The trailing 16ms Task.Delay is now
just compositor breathing room rather than the entire safety margin.

Same pattern WaitForIdleAsync uses internally and what the no-host
fallback already did — pulled up so the host-present path benefits too.

Verified with 3 local 10x sweeps:
  before:  4/10 clean, 5 distinct flaky fixtures, top offender 3/10
  v1 fix:  7/10 clean (yield before UpdateLayout — wrong order, didn't
           drain layout-spawned work)
  final:  10/10 clean, 0 flakes

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: codemonkeychris

tests/Reactor.AppTests.Host/SelfTest/Harness.cs

@@ -229,16 +229,31 @@ public static async Task Render(int ms = 0)
         {
             await host.WaitForIdleAsync();
         }
-        else
-        {
-            // No active host — yield once at Low priority as a fallback
-            var dq = DispatcherQueue.GetForCurrentThread();
-            var tcs = new TaskCompletionSource();
-            dq.TryEnqueue(DispatcherQueuePriority.Low, () => tcs.SetResult());
-            await tcs.Task;
-        }
 
-        // Force synchronous layout so ActualWidth/ActualHeight are ready
+        var dq = DispatcherQueue.GetForCurrentThread();
+
+        // Force synchronous layout so ActualWidth/ActualHeight are ready.
+        // This is also what triggers TabView's selected-tab content presenter
+        // to schedule its content-realization work onto the dispatcher.
+        (_currentWindow?.Content as UIElement)?.UpdateLayout();
+
+        // Yield once at Low priority AFTER UpdateLayout. WaitForIdleAsync
+        // short-circuits when Reactor reports idle; that left callers racing
+        // the WinUI side because TabView lazy-realizes the selected pane's
+        // body via Normal-priority dispatcher messages SCHEDULED BY the
+        // layout pass we just forced. A Low-priority yield here guarantees
+        // those messages have drained — without it, a 16ms wall-clock delay
+        // is enough on CI but flakes on contended local machines (visible
+        // in NativeDocking_* fixtures where the pane Memo subtree probes
+        // returned null ~30–60% of the time on local 10x sweeps).
+        var yieldTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        if (!dq.TryEnqueue(DispatcherQueuePriority.Low, () => yieldTcs.SetResult()))
+            yieldTcs.SetResult();
+        await yieldTcs.Task;
+
+        // Re-run layout in case the just-realized content needs an arrangement
+        // pass (e.g. a Memo body that mounted during the yield needs to size
+        // its TextBlocks before FindText can match by exact-text).
         (_currentWindow?.Content as UIElement)?.UpdateLayout();
 
         // Small breathing room for the compositor to finish processing