fix(ext/node): support numeric FDs in child_process stdio array (#33140)

## Summary

Now that `fs.openSync` returns real OS file descriptors (#33039),
numeric values in child_process stdio arrays should be treated as raw fds rather
than Deno resource IDs. This re-lands the functionality from #32959
(reverted in #33017) with the correct fd-based approach.

- Rename `StdioOrRid` to `StdioOrFd`, replace `Rid(ResourceId)` with
`Fd(i32)`
- `as_stdio()` dups the fd directly (`libc::dup` on Unix, handle clone
on Windows) instead of looking up the resource table
- `extra_stdio` now accepts `StdioOrFd` so numeric fds work beyond
stdin/stdout/stderr
- Hardcoded `Rid(1)`/`Rid(2)` for inherit become `Fd(1)`/`Fd(2)`
- Remove unused `FileResource` import

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bartlomieju

ext/io/lib.rs

@@ -262,31 +262,50 @@ deno_core::extension!(deno_io,
       ));
       assert_eq!(rid, 0, "stdin must have ResourceId 0");
 
-      let rid = t.add(FileResource::new(
-        Rc::new(match stdio.stdout.pipe {
-          StdioPipeInner::Inherit => StdFileResourceInner::new(
+      let (stdout_inner, child_stdout) = match stdio.stdout.pipe {
+        StdioPipeInner::Inherit => (
+          StdFileResourceInner::new(
             StdFileResourceKind::Stdout,
             STDOUT_HANDLE.try_clone().unwrap(),
             None,
           ),
-          StdioPipeInner::File(pipe) => StdFileResourceInner::file(pipe, None),
-        }),
+          STDOUT_HANDLE.try_clone().unwrap(),
+        ),
+        StdioPipeInner::File(pipe) => {
+          let child_handle = pipe.try_clone().unwrap();
+          (StdFileResourceInner::file(pipe, None), child_handle)
+        }
+      };
+      let rid = t.add(FileResource::new(
+        Rc::new(stdout_inner),
         "stdout".to_string(),
       ));
       assert_eq!(rid, 1, "stdout must have ResourceId 1");
 
-      let rid = t.add(FileResource::new(
-        Rc::new(match stdio.stderr.pipe {
-          StdioPipeInner::Inherit => StdFileResourceInner::new(
+      let (stderr_inner, child_stderr) = match stdio.stderr.pipe {
+        StdioPipeInner::Inherit => (
+          StdFileResourceInner::new(
             StdFileResourceKind::Stderr,
             STDERR_HANDLE.try_clone().unwrap(),
             None,
           ),
-          StdioPipeInner::File(pipe) => StdFileResourceInner::file(pipe, None),
-        }),
+          STDERR_HANDLE.try_clone().unwrap(),
+        ),
+        StdioPipeInner::File(pipe) => {
+          let child_handle = pipe.try_clone().unwrap();
+          (StdFileResourceInner::file(pipe, None), child_handle)
+        }
+      };
+      let rid = t.add(FileResource::new(
+        Rc::new(stderr_inner),
         "stderr".to_string(),
       ));
       assert_eq!(rid, 2, "stderr must have ResourceId 2");
+
+      state.put(ChildProcessStdio {
+        stdout: child_stdout,
+        stderr: child_stderr,
+      });
     }
   },
 );
@@ -339,6 +358,18 @@ pub struct Stdio {
   pub stderr: StdioPipe,
 }
 
+/// Holds the effective stdout/stderr handles for child process inheritance.
+///
+/// When the runtime redirects stdout/stderr (e.g. during `deno test` for
+/// output capture), child processes spawned with `stdio: "inherit"` need
+/// to inherit the redirected handles, not the original OS stdout/stderr.
+/// This struct is stored in `OpState` during IO extension init and read
+/// by the process extension when spawning children.
+pub struct ChildProcessStdio {
+  pub stdout: StdFile,
+  pub stderr: StdFile,
+}
+
 #[derive(Debug)]
 pub struct WriteOnlyResource<S> {
   stream: AsyncRefCell<S>,

ext/node/polyfills/internal/child_process.ts

@@ -748,7 +748,7 @@ function toDenoStdio(
     return "inherit";
   }
   if (typeof pipe === "number") {
-    /* Assume it's a rid returned by fs APIs */
+    /* Real OS file descriptor, e.g. from fs.openSync() */
     return pipe;
   }