#42150 terminal: release the wrapper after PTY EOF leaves input unflushed

Reproduction on released bun (1.4.3-canary.1, Linux x64, kernel 7.0):

let proc = Bun.spawn(["sh", "-c", "exit 0"], { terminal: { data() {}, exit() {}, drain() {} } });
const big = Buffer.alloc(65536, "a\n");
for (let i = 0; i < 32; i++) proc.terminal.write(big);   // ~2 MB the child never reads
await proc.exited;

• Leak: with a FinalizationRegistry on proc.terminal and a Bun.gc(true) loop, 0 of 5 wrappers are collected. Without the write() calls, 5 of 5.
• Fds: /dev/fd grows by 3 per terminal (master plus the reader and writer dups) and never shrinks. With the fix it returns to the baseline once the wrappers are collected.
• Spin: process.cpuUsage() over 2 s of idle after proc.exited reports 2603 ms of CPU. Without the write, 3 ms. With the fix, 39 ms.
• Post-exit writes: 64 MB of terminal.write() after proc.exited grows RSS by 178 MB on 1.4.3 (256 MB grows it by 491 MB). With the fix, 3 to 4 MB.
• Size: there is no clean threshold. The wrapper leaks whenever part of the input is still queued in the writer at EOF (8 KB of lines was enough here, 12 KB happened to fit) and, at any size, whenever echo arrives after the EIO (seen with 1 KB). With an unterminated line the kernel keeps discarding input, so an unfixed build drains after a few hundred ms, fires a late drain, and then releases the wrapper; with complete lines the queue is stuck for good.

Why the reader is closed too: on Linux the master read fails with EIO as soon as the last slave fd closes, but the slave's line discipline keeps processing input that was already queued and echoes it back, so later reads return data again. The reader's poll stayed armed after the error, delivered those chunks to data after exit, and the old CONNECTED branch re-rooted the wrapper on the first one. EOF (the macOS path) already closes the reader inside BufferedReader; the error path now matches it.

Why the writer is ended in Terminal and not in PosixPipeWriter::on_poll: a first version made on_poll report EndOfFile when a short write met POLLHUP, for every posix writer. With the terminal change in place the pty case no longer reaches that branch (measured: the spin is gone with the terminal change alone), and pipes and sockets fail with EPIPE or ECONNRESET there instead, so the generic change had no reachable case and was dropped.

write() after PTY EOF returns the byte length and drops the bytes. Before this change the same call also returned the byte length but queued the bytes in the writer forever (the RSS numbers above), so the return value is unchanged and the memory growth is gone. Throwing was rejected because terminal.closed is still false in that state.

Windows is unchanged: its writer already reports close when the conhost input pipe breaks, and the test is skipped there because it spawns sh.

test/js/bun/spawn/spawn-pipe-leak.test.ts fails the same way in my container on main and on this branch (three 500-process leak tests time out at 30 s on a debug ASAN build), so it is not a regression from this diff.

Self-reviewed: the review asked for the fd assertion, the post-exit write coverage, the regression origin and the measured consequences in this body, and deletion of the dead CONNECTED state instead of a guard. All done. An RSS assertion was not added: the post-exit writes in the test already fail the collection and fd checks on a build without the write() guard (verified by removing it), and RSS bounds are noisy under ASAN.

cargo check -p bun_runtime is clean for x86_64-pc-windows-msvc and aarch64-apple-darwin.