The newly added test discovered a bug on Linux where Process.Kill(entireProcessTree: true) fails to kill grandchild processes when an intermediate child has PR_SET_PDEATHSIG set (exposed via ProcessStartInfo.KillOnParentExit). Killing the root immediately terminates the intermediate child (via parent death signal) before the tree traversal can discover its descendants.

The test passes on Windows without any code changes — on Windows every process inherits Job objects from the parent process (unless they explicitly escape the Job), so the grandchild is already part of the same Job and gets terminated along with its parent. The bug described in issue #107992 could not be reproduced because Job objects are inherited by grandchild processes.

Summary

Fixes a Linux-specific bug in Process.Kill(entireProcessTree: true) where grandchild processes were left running when an intermediate child had PR_SET_PDEATHSIG (KillOnParentExit) set. The fix introduces a two-phase stop-then-kill algorithm: recursively SIGSTOP the entire tree first (collecting all processes into a flat list), then SIGKILL all collected processes. This ensures the full tree is discovered while all processes are alive and stopped, before any kill signals trigger cascading parent-death signal deaths.

Previously, the algorithm killed each process immediately after enumerating its direct children. This caused processes with PR_SET_PDEATHSIG (KillOnParentExit) to be killed by the kernel before their own children could be discovered, leaving grandchild processes orphaned and running.

Changes

Fix: Unix KillTree in Process.Unix.cs

Refactored the KillTree method to use a two-phase stop-then-kill approach:

1. StopTree: Recursively SIGSTOPs all processes depth-first and collects them into a flat list. This captures the entire tree while all processes are alive and stopped. Returns true if the process was successfully stopped and added to the list, false if it exited early or SIGSTOP failed (in which case the caller disposes it). The kill/dispose loop runs in a finally block so it always executes even if StopTree throws partway through.
2. Kill phase: SIGKILLs all collected (already stopped) processes.

Additional robustness improvements applied during code review:

• StopTree returns bool so the caller can immediately dispose child Process instances that were not added to stoppedProcesses (exited early or SIGSTOP failed), preventing resource leaks.
• The kill/dispose loop runs in a finally block, ensuring already-stopped processes are always killed and disposed even if StopTree throws partway through tree enumeration.
• errno is captured into GetLastErrorInfo().RawErrno before any other allocation and passed explicitly to Win32Exception, preventing it from being clobbered.

Test: Regression test in KillOnParentExitTests.cs

Adds a [ConditionalTheory] parameterized with [InlineData(true)] and [InlineData(false)] that creates a 3-level process hierarchy:

Process A (root)
  └── Process B (KillOnParentExit=enabled, controlled by parameter)
        └── Process C (not in job object, should be killed)

• Calls Kill(entireProcessTree: true) on Process A
• Asserts Process C is also terminated
• Verifies behavior regardless of whether KillOnParentExit is enabled on the intermediate child
• Runs on all platforms supported by the test class (no [PlatformSpecific] or [ActiveIssue] guards)

Testing

• All KillOnParentExitTests pass on Linux for both enabled: true and enabled: false cases
• All ProcessTests pass on Linux (226 tests, 0 failures)