Restore E2E test hardening reverted with the Windows PowerShell skips

PR #2328 reset the three E2E test files to their pre-#2318 state
(`b57653c40`) to undo the Windows PowerShell skips we no longer want now
that the host-start hang is actually fixed. But #2318 was a squash that
bundled genuine harness hardening *alongside* those skips, so reverting
wholesale quietly dropped the good parts too. Restore just those, keeping
the skips reverted:

- `ReadScriptLogLineAsync` now yields with `await Task.Delay(100)` at EOF
  instead of busy-spinning. At EOF `ReadLineAsync` completes synchronously
  with `null`, so the old `while`/`await` loop never released its
  thread-pool thread and could starve the scheduler on constrained CI
  runners.
- The child-process `Debug-Runspace` readiness poll in
  `CanAttachScriptWithPathMappings` sleeps 100ms per iteration so it can't
  peg a core during the attach handshake.
- `LSPTestsFixture.DisposeAsync` guards against a null `PsesLanguageClient`
  so a startup failure isn't masked by a `NullReferenceException` during
  teardown.

These are defense-in-depth independent of the skips, and they matter more
now that we un-skip: a Windows PowerShell server that fails to start
shouldn't busy-spin or NRE on teardown.

Drafted by Copilot (Claude Opus 4.8).

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

Author: andyleejordan

test/PowerShellEditorServices.Test.E2E/DebugAdapterProtocolMessageTests.cs

@@ -238,13 +238,22 @@ private async Task<string> ReadScriptLogLineAsync()
                 }
             }
 
-            // return valid lines only
-            string nextLine = string.Empty;
-            while (nextLine is null || nextLine.Length == 0)
+            // Tail the log until a non-empty line is available. The awaited
+            // delay between reads matters: at EOF ReadLineAsync completes
+            // synchronously with null, so without it this is a tight loop that
+            // never releases its thread-pool thread and needlessly pressures
+            // the pool on constrained CI runners. Yielding keeps the tail loop
+            // cheap while we wait for the script to write.
+            while (true)
             {
-                nextLine = await scriptLogReader.ReadLineAsync(); //Might return null if at EOF because we created it above but the script hasn't written to it yet
+                string nextLine = await scriptLogReader.ReadLineAsync();
+                if (!string.IsNullOrEmpty(nextLine))
+                {
+                    return nextLine;
+                }
+
+                await Task.Delay(100);
             }
-            return nextLine;
         }
 
         [Fact]
@@ -762,6 +771,10 @@ WinPS will always need this.
                     if (((Get-Date) - $start).TotalSeconds -gt 10) {
                         throw 'Timeout waiting for Debug-Runspace to be subscribed.'
                     }
+
+                    # Yield a slice so this poll doesn't peg a core while the
+                    # runner is also servicing the attach handshake.
+                    Start-Sleep -Milliseconds 100
                 }
 
                 $ps.Invoke()

test/PowerShellEditorServices.Test.E2E/LSPTestsFixtures.cs

@@ -100,9 +100,19 @@ public async Task InitializeAsync()
 
         public async Task DisposeAsync()
         {
+            // If InitializeAsync failed before the client connected (e.g. the
+            // server never finished starting), PsesLanguageClient was never
+            // assigned, so there is nothing to shut down. Guarding here keeps a
+            // startup failure from being masked by a NullReferenceException
+            // during teardown.
+            if (PsesLanguageClient is null)
+            {
+                return;
+            }
+
             await PsesLanguageClient.Shutdown();
             await _psesHost.Stop();
-            PsesLanguageClient?.Dispose();
+            PsesLanguageClient.Dispose();
         }
     }
 }