feat: process exit codes, posix_spawn, 4 KiB command lines

Groundwork for the GCC driver: a compiler driver must spawn cc1/as/ld
and know whether each stage succeeded.

Kernel: the scheduler keeps an exit-code ledger (pid -> code; pids are
monotonic so entries never alias), published during teardown right
before waiters wake. SYS_EXIT records main()'s return value, SYS_KILL
records 256+SIGKILL, and the exception handler records 256+signal
mapped from the fault vector (#PF/#GP -> SIGSEGV, #DE/FP -> SIGFPE,
#UD -> SIGILL). SYS_WAITPID now returns the code: 0..255 for a normal
exit, 256+signal for a violent death. Process args grow from 256
bytes to 4 KiB (cc1 invocations do not fit in 256), with crt1 now
parsing up to 255 argv entries from a static buffer.

libc: new spawn.h with posix_spawn/posix_spawnp over SYS_SPAWN -
libiberty's pex layer has a posix_spawn backend, so GCC's driver works
without fork. argv is joined into the kernel args string (spaces in
arguments rejected; no kernel quoting), envp is not transferred, and
non-empty file actions fail loudly with ENOTSUP until the kernel can
redirect stdio on spawn. waitpid() now decodes real POSIX status and
the sys/wait.h macros distinguish exited from signaled children.

Shell: prints [exit code N] after nonzero exits and [terminated by
signal N] for killed or crashed children.

Verified on the OS: cat on a missing file reports exit code 1; a
window-close (clean exit 0) stays silent as it should.

Co-Authored-By: Claude Fable 5 <[email protected]>

programs/lib/libc/crt/crt1.c

@@ -37,23 +37,24 @@ static inline long _sys2(long nr, long a1, long a2) {
 extern int main(int argc, char** argv);
 
 void _start(void) {
-    char argbuf[256];
+    /* Static: 4 KiB args + 256 argv slots would crowd a 32 KiB stack. */
+    static char argbuf[4096];
+    static char* argv[256];
     int len = (int)_sys2(SYS_GETARGS, (long)argbuf, (long)sizeof(argbuf));
 
-    char* argv[32];
     int argc = 0;
 
     argv[argc++] = (char*)"prog";
 
     if (len > 0) {
-        if (len > 255) {
-            len = 255;
+        if (len > (int)sizeof(argbuf) - 1) {
+            len = (int)sizeof(argbuf) - 1;
         }
 
         argbuf[len] = '\0';
 
         char* p = argbuf;
-        while (*p != '\0' && argc < 31) {
+        while (*p != '\0' && argc < 255) {
             while (*p == ' ') {
                 p++;
             }