Post-reorg cleanup: POSIX layer, and naming fixes

Follow-up to the monorepo re-org. Suite 35/35 plus host tests green.

POSIX compatibility is now its own library, library/posix/ (unistd, stdio),
layered strictly over the runtime — it calls the runtime's IPC/heap, never
system calls directly. The runtime is now POSIX-free (the danos-native
application ABI). The VFS wire protocol is danos-native throughout
(Stat -> FileStatus, .stat -> .status, O_CREAT -> create); the POSIX layer
maps the POSIX spellings at the boundary. The coding standard's ABI-name
exception is scoped to one place: a file is allowed POSIX spellings only if it
lives under library/posix/ — everywhere else, danos naming with no exception.

Naming fixes, all mechanical:
- initrd -> initial-ramdisk: the source file, the module, the tool
  (make-initial-ramdisk.py), the artifact (initial-ramdisk.img, including the
  bootloader's load path), and the identifiers.
- system/kernel/device-service.zig -> devices-broker.zig: it is ring-0 kernel
  code (the trusted device table + claim capability), not a ring-3 service. The
  future user-space device *manager* (policy) will live in system/services/.
- Dropped the daemon `d` suffix: hpetd -> hpet, busd -> bus. A driver lives in
  system/drivers/, so the folder already says what it is; encoding the role in
  the name too is redundant. The coding standard drops that exception.
- system/devices/aml/interp.zig -> interpreter.zig (the type was already
  Interpreter).

library/posix/posix.zig

@@ -0,0 +1,13 @@
+//! DanOS's POSIX / C compatibility layer — `unistd`, `stdio`, and (later) the C
+//! `errno` / `struct stat` / `extern "C"` surface. This is the *one* place POSIX and
+//! C spellings are allowed to appear verbatim (see docs/coding-standards.md): a file
+//! under library/posix/ *is* the foreign ABI, so it keeps the ABI's names. Everything
+//! it touches on the danos side (the VFS protocol, the runtime) uses danos names,
+//! which this layer translates to at the boundary.
+//!
+//! It is layered strictly *over* the runtime: it calls the runtime's IPC and heap,
+//! never the kernel's system calls directly. danos-native applications use the
+//! runtime; this exists so *POSIX* software can too.
+
+pub const unistd = @import("unistd.zig");
+pub const stdio = @import("stdio.zig");

library/posix/stdio.zig

@@ -5,7 +5,7 @@
 
 const std = @import("std");
 const unistd = @import("unistd.zig");
-const heap = @import("heap.zig");
+const heap = @import("runtime").heap;
 
 pub const SEEK_SET = unistd.SEEK_SET;
 pub const SEEK_CURRENT = unistd.SEEK_CURRENT;

library/posix/unistd.zig

@@ -5,10 +5,10 @@
 
 const std = @import("std");
 const protocol = @import("vfs-protocol");
-const ipc = @import("ipc.zig");
+const ipc = @import("runtime").ipc;
 const danos = @import("danos");
 
-pub const O_CREAT = protocol.O_CREAT;
+pub const O_CREAT = protocol.create;
 pub const SEEK_SET: u32 = 0;
 pub const SEEK_CURRENT: u32 = 1;
 pub const SEEK_END: u32 = 2;
@@ -110,11 +110,11 @@ pub fn lseek(fd: i32, off: i64, whence: u32) i64 {
         SEEK_SET => 0,
         SEEK_CURRENT => @intCast(f.offset),
         SEEK_END => blk: {
-            const request = protocol.Request{ .operation = .stat, .node = f.node, .offset = 0, .len = 0, .flags = 0 };
-            var sbuf: [@sizeOf(protocol.Stat)]u8 = undefined;
+            const request = protocol.Request{ .operation = .status, .node = f.node, .offset = 0, .len = 0, .flags = 0 };
+            var sbuf: [@sizeOf(protocol.FileStatus)]u8 = undefined;
             const r = transact(request, &.{}, &sbuf) orelse return -1;
-            if (r.reply.status != 0 or r.payload.len < @sizeOf(protocol.Stat)) return -1;
-            const st = std.mem.bytesToValue(protocol.Stat, sbuf[0..@sizeOf(protocol.Stat)]);
+            if (r.reply.status != 0 or r.payload.len < @sizeOf(protocol.FileStatus)) return -1;
+            const st = std.mem.bytesToValue(protocol.FileStatus, sbuf[0..@sizeOf(protocol.FileStatus)]);
             break :blk @intCast(st.size);
         },
         else => return -1,
@@ -126,17 +126,17 @@ pub fn lseek(fd: i32, off: i64, whence: u32) i64 {
 }
 
 /// Stat `path`. Returns 0 or -1.
-pub fn stat(path: []const u8, out: *protocol.Stat) i32 {
+pub fn stat(path: []const u8, out: *protocol.FileStatus) i32 {
     // Open, stat by node, close — simple and enough for now.
     const fd = open(path, 0);
     if (fd < 0) return -1;
     defer close(fd);
     const f = fdPtr(fd).?;
-    const request = protocol.Request{ .operation = .stat, .node = f.node, .offset = 0, .len = 0, .flags = 0 };
-    var sbuf: [@sizeOf(protocol.Stat)]u8 = undefined;
+    const request = protocol.Request{ .operation = .status, .node = f.node, .offset = 0, .len = 0, .flags = 0 };
+    var sbuf: [@sizeOf(protocol.FileStatus)]u8 = undefined;
     const r = transact(request, &.{}, &sbuf) orelse return -1;
-    if (r.reply.status != 0 or r.payload.len < @sizeOf(protocol.Stat)) return -1;
-    out.* = std.mem.bytesToValue(protocol.Stat, sbuf[0..@sizeOf(protocol.Stat)]);
+    if (r.reply.status != 0 or r.payload.len < @sizeOf(protocol.FileStatus)) return -1;
+    out.* = std.mem.bytesToValue(protocol.FileStatus, sbuf[0..@sizeOf(protocol.FileStatus)]);
     return 0;
 }
 

library/runtime/runtime.zig

@@ -17,9 +17,7 @@ pub const start = @import("start.zig");
 /// The VFS wire protocol (shared with the VFS server).
 pub const vfs_protocol = @import("vfs-protocol");
 /// POSIX-style file API: open/read/write/lseek/stat/close.
-pub const unistd = @import("unistd.zig");
 /// C stdio: fopen/fread/fwrite/fseek/ftell/fclose over unistd.
-pub const stdio = @import("stdio.zig");
 /// Device access for drivers: enumerate/claim/mmioMap.
 pub const device = @import("device.zig");