fix(streams): dedup HostWrite against whitespace-normalized pipeline lines

Format-Table / Format-Wide / Format-List output rendered through
Out-String (in Format-McpOutput) and Out-Host (visible terminal)
calculate column padding from different sources — Out-String uses the
IRawUserInterface buffer width (often 120) while Out-Host uses the
actual visible-terminal width. Both renders carry the same data but
inter-column spacing differs by one or more characters per row, e.g.

    pipeline section: "AdobeARMservice            ADPSvc"   (12 sp)
    HOST.UI section:  "AdobeARMservice           ADPSvc"    (11 sp)

The existing exact-match HashSet and substring-contain checks both
miss this shape (neither line is a substring of the other), so every
row of a Format-X table that exhibits the drift gets duplicated into
the === HOST.UI (direct) === section.

Add a parallel whitespace-normalized HashSet (consecutive whitespace
runs collapsed to a single space). HostWrite candidate lines are
checked against the exact set first, then the normalized set, then
the substring containment loop. The normalized check catches the
column-width drift cleanly without affecting the existing dedup
paths — legitimate host-UI lines that happen to normalise the same as
a pipeline line are virtually impossible in practice.

Verified on Format-Wide (Get-Service | Format-Wide -Column 4) and
large Format-Table (30+ rows of pscustomobject) — both previously
showed full duplicates in HOST.UI section, now produce a single clean
pipeline-section render. xunit + Pester suites all green.

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

Author: yotsuda

PowerShell.MCP/Resources/MCPPollingEngine.ps1

@@ -653,12 +653,32 @@ if (-not (Test-Path Variable:global:McpTimer)) {
                         # section as plain text duplicates.
                         $known = [System.Collections.Generic.HashSet[string]]::new(
                             [System.StringComparer]::Ordinal)
+                        # Whitespace-collapsed parallel set: catches the
+                        # Out-String vs Out-Host column-width drift on
+                        # Format-Table / Format-Wide / Format-List.
+                        # Out-String uses the IRawUserInterface buffer
+                        # width (often 120) while Out-Host uses the
+                        # actual visible terminal width, so the same
+                        # row often ends up with one space difference
+                        # in inter-column padding ("xxx   yyy" vs
+                        # "xxx    yyy"). Exact-match and substring
+                        # checks both miss it. Normalising whitespace
+                        # runs to a single space catches these without
+                        # affecting other dedup paths (legitimate
+                        # host-UI lines that happen to normalise the
+                        # same as a pipeline line are virtually
+                        # impossible in practice).
+                        $knownNorm = [System.Collections.Generic.HashSet[string]]::new(
+                            [System.StringComparer]::Ordinal)
                         foreach ($src in @($pipelineText, $exceptionText, $infoText, $consoleOutText, $consoleErrText)) {
                             if (-not [string]::IsNullOrEmpty($src)) {
                                 $srcStripped = $src -replace $vtPattern, ""
                                 foreach ($line in $srcStripped -split "`r?`n") {
                                     $trimmed = $line.Trim()
-                                    if ($trimmed) { [void]$known.Add($trimmed) }
+                                    if ($trimmed) {
+                                        [void]$known.Add($trimmed)
+                                        [void]$knownNorm.Add(($trimmed -replace '\s+', ' '))
+                                    }
                                 }
                             }
                         }
@@ -667,6 +687,8 @@ if (-not (Test-Path Variable:global:McpTimer)) {
                             $trimmed = $line.Trim()
                             if (-not $trimmed) { continue }
                             if ($known.Contains($trimmed)) { continue }
+                            $normalized = $trimmed -replace '\s+', ' '
+                            if ($knownNorm.Contains($normalized)) { continue }
                             # Check substring containment for partial
                             # matches: Out-Host renders ErrorRecord
                             # through a multi-line formatter so a