Make OnIdle tests deterministic by polling instead of sleeping

`CanRunOnIdleTask` (and its twin `CanRunOnIdleInProfileTask`) were flaky on
the net462 (Windows PowerShell 5.1) CI leg — the former was just caught
failing on PR #2298's Windows job.

The root cause is that `PsesInternalHost.OnPowerShellIdle` calls
`Events.GenerateEvent(PSEngineEvent.OnIdle, ...)`, which only *enqueues* the
event. For a subscriber registered with `-Action {...}`, PowerShell doesn't
run the action scriptblock inline; it becomes a pending action that the
engine dispatches asynchronously on the pipeline thread, around subsequent
pipeline invocations. So the action's execution was never synchronized with
the test's `$handled` read, and the fixed `Thread.Sleep(2000)` was just a
timing guess — sometimes too short on the slower WinPS leg, leaving
`$global:handled` still `$false` at the assertion.

The key realization is that each *additional* pipeline execution gives the
engine another chance to drain the pending action, so re-reading the handler
variable in a loop both waits for *and* drives completion. I replaced the
sleep with a shared `WaitForHandledAsync` helper that polls the variable
(~200ms apart, ~15s ceiling) until it reports `$true`, returning the last
observed value on timeout so the assertion still fails loudly. This keeps the
tests' intent intact and isn't merely a longer sleep.

I validated both tests on net8.0 (green across repeated runs, ~0.4s each vs.
the old fixed 2s); net462 can't run on macOS, but the mechanism is identical
across targets and the 15s ceiling self-terminates on success, so it's
strictly safer on the slow leg without slowing the fast one.

Drafted by Copilot (Claude Opus 4.8).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: andyleejordan

test/PowerShellEditorServices.Test/Session/PsesInternalHostTests.cs

@@ -19,6 +19,38 @@ namespace PowerShellEditorServices.Test.Session
     using System.Management.Automation;
     using System.Management.Automation.Runspaces;
 
+    // Shared helpers for the OnIdle engine-event tests, whose handler actions are
+    // dispatched asynchronously by PowerShell's event manager.
+    internal static class OnIdleTestHelpers
+    {
+        // The OnIdle engine event's -Action scriptblock is not run inline when
+        // OnPowerShellIdle generates the event; PowerShell enqueues it as a pending
+        // action and dispatches it asynchronously around subsequent pipeline executions.
+        // So instead of sleeping a fixed amount, poll the handler variable until it
+        // reports true (each read is itself a pipeline, giving the engine another chance
+        // to drain the pending action). On timeout we return the last observed value so
+        // the caller's assertion still fails loudly.
+        internal static async Task<IReadOnlyList<bool>> WaitForHandledAsync(
+            PsesInternalHost psesHost, string variableName)
+        {
+            using CancellationTokenSource cancellationSource = new(millisecondsDelay: 15000);
+            IReadOnlyList<bool> handled = Array.Empty<bool>();
+            while (true)
+            {
+                handled = await psesHost.ExecutePSCommandAsync<bool>(
+                    new PSCommand().AddScript(variableName),
+                    CancellationToken.None);
+
+                if ((handled.Count > 0 && handled[0]) || cancellationSource.IsCancellationRequested)
+                {
+                    return handled;
+                }
+
+                await Task.Delay(200);
+            }
+        }
+    }
+
     [Trait("Category", "PsesInternalHost")]
     public class PsesInternalHostTests : IAsyncLifetime
     {
@@ -203,12 +235,7 @@ await psesHost.ExecuteDelegateAsync(
                 (_, _) => psesHost.OnPowerShellIdle(CancellationToken.None),
                 CancellationToken.None);
 
-            // TODO: Why is this racy?
-            Thread.Sleep(2000);
-
-            handled = await psesHost.ExecutePSCommandAsync<bool>(
-                new PSCommand().AddScript("$handled"),
-                CancellationToken.None);
+            handled = await OnIdleTestHelpers.WaitForHandledAsync(psesHost, "$handled");
 
             Assert.Collection(handled, Assert.True);
         }
@@ -303,12 +330,7 @@ await psesHost.ExecuteDelegateAsync(
                 (_, _) => psesHost.OnPowerShellIdle(CancellationToken.None),
                 CancellationToken.None);
 
-            // TODO: Why is this racy?
-            Thread.Sleep(2000);
-
-            IReadOnlyList<bool> handled = await psesHost.ExecutePSCommandAsync<bool>(
-                new PSCommand().AddScript("$handledInProfile"),
-                CancellationToken.None);
+            IReadOnlyList<bool> handled = await OnIdleTestHelpers.WaitForHandledAsync(psesHost, "$handledInProfile");
 
             Assert.Collection(handled, Assert.True);
         }