Make re-arm safe under Constrained Language Mode

Addresses Copilot review on PR #662.

__ShellInteg_Rearm compared prompt identity with [object]::ReferenceEquals.
Re-arm runs unconditionally at script load and from PSConsoleHostReadLine, and
under Constrained Language Mode a static method call is blocked. Confirmed:

    Cannot invoke method. Method invocation is supported only on core types
    in this language mode.

and the failure ABORTS the enclosing script even from inside try/catch, so it
would break profile sourcing or the input path. This is the same hazard the
script already guards elsewhere via $Global:__ShellInteg_CanInspectErrors.

Rather than no-op under Constrained Language Mode, identity is now compared
with -eq. ScriptBlock does not override Equals, so -eq IS reference identity
(verified: two scriptblocks with identical text compare False, the same object
compares True), and the operator is permitted in Constrained Language Mode.
Re-arming therefore keeps working there instead of being disabled.

Verified end-to-end under ConstrainedLanguage on Windows PowerShell 5.1 and
PowerShell 7: sourcing the script, rendering the prompt with marks, and the
input path all succeed with no exception. Note re-arm still has no per-command
driver in that mode because the PSConsoleHostReadLine wrapper is gated behind
CanInspectErrors - pre-existing v6 behaviour, unchanged here - so integration
degrades gracefully rather than self-healing.

Also fixes the repo's forbidden-spelling rule ('re-entrancy' -> 'reentrancy')
in the new tests, and adds an assertion that re-arm contains no static method
call at all, so this cannot regress.

104/104 ShellIntegrationTests pass.

Author: yeelam-gordon

src/cascadia/UnitTests_TerminalCore/ShellIntegrationTests.cpp

@@ -515,7 +515,11 @@ void ShellIntegrationTests::PowerShell_ScriptContent_ReArmsFromReadLineBoundary(
     // Detection is by object identity against our own scriptblock — never by
     // text matching, which a renderer could accidentally satisfy.
     const auto rearmFunc = script.find("function Global:__ShellInteg_Rearm");
-    const auto identityCheck = script.find("[object]::ReferenceEquals($current, $Global:__ShellInteg_Wrapper)", rearmFunc);
+    // -eq, NOT [object]::ReferenceEquals: re-arm runs at script load and from the
+    // readline boundary, and a static method call under Constrained Language Mode
+    // aborts the enclosing script even from inside try/catch.
+    const auto identityCheck = script.find("if ($current -eq $Global:__ShellInteg_Wrapper) { return }", rearmFunc);
+    const auto noStaticCall = script.substr(rearmFunc).find("[object]::ReferenceEquals");
     const auto adopt = script.find("$Global:__ShellInteg_OriginalPrompt = $current", identityCheck);
     const auto reinstall = script.find("Set-Item Function:\\global:prompt $Global:__ShellInteg_Wrapper", adopt);
 
@@ -531,6 +535,8 @@ void ShellIntegrationTests::PowerShell_ScriptContent_ReArmsFromReadLineBoundary(
                    L"The wrapper scriptblock must be captured after prompt is defined");
     VERIFY_IS_TRUE(rearmFunc < identityCheck && identityCheck < adopt && adopt < reinstall,
                    L"Re-arm must detect replacement by object identity, adopt the newcomer, then reinstall the wrapper");
+    VERIFY_ARE_EQUAL(std::string::npos, noStaticCall,
+                     L"Re-arm must not invoke static methods - blocked in Constrained Language Mode, and the failure aborts the script even from inside try/catch");
 }
 
 void ShellIntegrationTests::PowerShell_ScriptContent_ReArmIsBestEffortAndSkipsWithoutWrapper()
@@ -606,9 +612,9 @@ void ShellIntegrationTests::PowerShell_ScriptContent_GuardsAgainstChainingPrompt
     VERIFY_ARE_NOT_EQUAL(std::string::npos, clearFlag);
     VERIFY_ARE_NOT_EQUAL(std::string::npos, retainPrev);
     VERIFY_IS_TRUE(promptStart < reentryGuard && reentryGuard < servePrev,
-                   L"Re-entry must be detected before any rendering work and serve the displaced prompt");
+                   L"reentry must be detected before any rendering work and serve the displaced prompt");
     VERIFY_IS_TRUE(setFlag < delegation && delegation < clearFlag,
-                   L"The re-entrancy flag must be set around the delegation and cleared in finally");
+                   L"The reentrancy flag must be set around the delegation and cleared in finally");
 }
 
 void ShellIntegrationTests::PowerShell_ScriptContent_RendersFailSafe()

src/cascadia/inc/PowerShellShellIntegration.h

@@ -613,17 +613,26 @@ function Global:__ShellInteg_Rearm {
     # the next shell, which sources only this version.
     if ($null -eq $Global:__ShellInteg_Wrapper) { return }
 
+    # Identity is compared with -eq rather than a static reference-equality
+    # method. This runs unconditionally at script load and from
+    # PSConsoleHostReadLine, and under Constrained Language Mode a static method
+    # call raises "Method invocation is supported only on core types", which
+    # aborts the enclosing script even from inside try/catch - breaking profile
+    # sourcing or the input path. ScriptBlock does not override Equals, so -eq is
+    # reference identity here (verified: two scriptblocks with identical text
+    # compare False), and the operator is permitted in Constrained Language Mode.
+    # That keeps re-arming working there instead of disabling it.
     $current = $function:prompt
     if ($null -eq $current) { return }
-    if ([object]::ReferenceEquals($current, $Global:__ShellInteg_Wrapper)) { return }
+    if ($current -eq $Global:__ShellInteg_Wrapper) { return }
 
     # Best-effort. This runs from PSConsoleHostReadLine, so a throw here would
     # break the input path, and at script load, where it would break profile
     # sourcing. `prompt` can legitimately be ReadOnly or Constant in a hardened
     # profile, which makes Set-Item raise SessionStateUnauthorizedAccessException.
     # Shell integration is a convenience; never let it take the shell down.
     try {
-        if (-not [object]::ReferenceEquals($current, $Global:__ShellInteg_OriginalPrompt)) {
+        if ($current -ne $Global:__ShellInteg_OriginalPrompt) {
             # Retain the renderer being displaced, in case the newcomer chains
             # back into us.
             $Global:__ShellInteg_PrevPrompt = $Global:__ShellInteg_OriginalPrompt