[PHP] Fix "Controller is already closed" crash in CLI server (#3441)

## Summary

This PR fixes two related Node-side crash paths in PHP-WASM that could
bring down the Playground CLI server instead of failing a single request
cleanly.

The first crash happened when PHP had already produced output, which
closes the headers stream, and then execution failed afterwards. In that
case, Node could still try to `error()` a `ReadableStream` controller
that had already been closed, which threw:

```text
TypeError [ERR_INVALID_STATE]: Invalid state: Controller is already closed
```

The validated repro for that path is:

1. PHP writes output
2. `closeHeadersStream()` closes the headers controller
3. a later WASM/runtime error occurs
4. error handling tries to signal the already-closed controller

A simple `echo ...; exit;` by itself is not the exact repro.

The second crash happened when a stream consumer cancelled the response
stream before PHP finished, for example because the HTTP pipeline
completed or the client disconnected. In that case, the runtime could
still try to `close()` an already-cancelled controller and hit the same
`Controller is already closed` failure.

The third crash path was in the `proc_open()` bridge used by the Node
PHP runtime. If a spawned process timed out or exited while Node still
had buffered stdout/stderr chunks to forward, the generated `php.js`
bridge could try to write into a PIPEFS stream that PHP had already
closed. That crashed the host with an error like:

```text
TypeError: Cannot read properties of null (reading 'length')
```

Example:

```php
<?php
$res = proc_open(
    "hanging_command",
    [
        ["pipe", "r"],
        ["pipe", "w"],
        ["pipe", "w"],
    ],
    $pipes
);
fread($pipes[1], 1024);
```

## What changed

- Added defensive stream-controller handling in the universal runtime
and stream bridge so already-closed controllers no longer crash the host
process.
- Fixed child stdout/stderr teardown in the Emscripten Node bridge by
detaching listeners on exit and ignoring late chunks after PHP has
already closed the child-side pipe.
- Added `off()` to the shared `EventEmitter` interface so the
child-process typing matches the APIs used by the runtime cleanup logic.
- Regenerated all checked-in Node PHP binaries (`asyncify` and `jspi`,
PHP 7.4 through 8.5) from the updated build source.

## Test plan

CI

Author: adamziel

packages/php-wasm/compile/php/phpwasm-emscripten-library.js

@@ -661,8 +661,12 @@ const LibraryExample = {
 				stdoutParentFd = std[1]?.parent,
 				stderrChildFd = std[2]?.child,
 				stderrParentFd = std[2]?.parent;
+			const detachPipeDataListeners = [];
 
 			cp.on('exit', function (code) {
+				for (const detach of detachPipeDataListeners) {
+					detach();
+				}
 				for (const fd of [
 					// The child process exited. Let's clean up its output streams:
 					stdoutChildFd,
@@ -689,16 +693,27 @@ const LibraryExample = {
 					stdoutChildFd
 				);
 				let stdoutAt = 0;
-				cp.stdout.on('data', function (data) {
-					stdoutStream.stream_ops.write(
-						stdoutStream,
-						data,
-						0,
-						data.length,
-						stdoutAt
-					);
-					stdoutAt += data.length;
-				});
+				const onStdoutData = function (data) {
+					try {
+						stdoutStream.stream_ops.write(
+							stdoutStream,
+							data,
+							0,
+							data.length,
+							stdoutAt
+						);
+						stdoutAt += data.length;
+					} catch {
+						// PHP may close the child pipe before Node finishes
+						// draining already-buffered stdout data. Late chunks are
+						// no longer deliverable, so detach the listener and stop.
+						cp.stdout.off('data', onStdoutData);
+					}
+				};
+				cp.stdout.on('data', onStdoutData);
+				detachPipeDataListeners.push(() =>
+					cp.stdout.off('data', onStdoutData)
+				);
 			}
 
 			// Pass data from child process's stderr to PHP's end of the stdout pipe.
@@ -707,16 +722,24 @@ const LibraryExample = {
 					stderrChildFd
 				);
 				let stderrAt = 0;
-				cp.stderr.on('data', function (data) {
-					stderrStream.stream_ops.write(
-						stderrStream,
-						data,
-						0,
-						data.length,
-						stderrAt
-					);
-					stderrAt += data.length;
-				});
+				const onStderrData = function (data) {
+					try {
+						stderrStream.stream_ops.write(
+							stderrStream,
+							data,
+							0,
+							data.length,
+							stderrAt
+						);
+						stderrAt += data.length;
+					} catch {
+						cp.stderr.off('data', onStderrData);
+					}
+				};
+				cp.stderr.on('data', onStderrData);
+				detachPipeDataListeners.push(() =>
+					cp.stderr.off('data', onStderrData)
+				);
 			}
 
 			/**