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).

system/services/vfs/protocol.zig

@@ -1,18 +1,22 @@
-//! The VFS wire protocol — the message format spoken between a client (via the
-//! `runtime` file API) and the user-space VFS server over IPC. A request is a fixed
-//! `Request` header followed by an inline payload (a path, or write bytes); a
-//! reply is a fixed `Reply` header followed by an inline payload (read bytes, or
-//! a Stat). Everything fits in one IPC message (<= ipc MESSAGE_MAXIMUM = 256 bytes).
+//! The VFS wire protocol — the message format spoken between a client (via the file
+//! API) and the user-space VFS server over IPC. A request is a fixed `Request` header
+//! followed by an inline payload (a path, or write bytes); a reply is a fixed `Reply`
+//! header followed by an inline payload (read bytes, or a FileStatus). Everything fits
+//! in one IPC message (<= ipc MESSAGE_MAXIMUM = 256 bytes).
+//!
+//! This is a danos-native contract, so it uses danos names throughout — the POSIX
+//! spellings (`stat`, `O_CREAT`, ...) live only in the POSIX layer
+//! (library/posix/unistd.zig), which translates to these.
 //!
 //! This is user-space only — the kernel knows nothing of files or paths; it only
-//! moves the bytes. Shared by library/runtime/unistd.zig (client) and system/services/vfs/vfs.zig (server).
+//! moves the bytes. Shared by library/posix/unistd.zig (client) and system/services/vfs/vfs.zig (server).
 
 pub const Operation = enum(u32) {
     open, // open(path) -> node id
     close, // close(node)
     read, // read(node, offset, len) -> bytes
     write, // write(node, offset, bytes) -> count
-    stat, // stat(node) -> Stat
+    status, // status(node) -> FileStatus
 };
 
 /// Request header. `node` is the server-side open-file id (from a prior open);
@@ -28,7 +32,7 @@ pub const Request = extern struct {
 
 /// Reply header. `status` is 0 on success or a negative errno; `node` is the new
 /// open-file id (for `open`); `len` is the payload length (bytes read, or the
-/// Stat size).
+/// FileStatus size).
 pub const Reply = extern struct {
     status: i32,
     _padding: u32 = 0,
@@ -37,7 +41,9 @@ pub const Reply = extern struct {
     _padding2: u32 = 0,
 };
 
-pub const Stat = extern struct {
+/// A file's metadata (the danos-native answer to a `status` request). The POSIX
+/// layer maps this onto `struct stat`.
+pub const FileStatus = extern struct {
     size: u64,
     kind: u32,
     _padding: u32 = 0,
@@ -49,5 +55,5 @@ pub const reply_size: usize = @sizeOf(Reply);
 /// Largest inline payload that still fits one IPC message alongside a header.
 pub const maximum_payload: usize = message_maximum - request_size;
 
-/// Open flags.
-pub const O_CREAT: u32 = 1;
+/// Open flags (danos-native; the POSIX layer maps `O_CREAT` onto `create`).
+pub const create: u32 = 1;

system/services/vfs/vfs-test.zig

@@ -1,13 +1,13 @@
 //! /sbin/vfstest — a client that proves the VFS round trip end to end: open a
 //! file through the `runtime` file API, write to it, seek back, read it, and compare.
 //! On success it heartbeats "vfstest: ok" so the kernel test can observe it;
-//! on failure it reports what went wrong. Shipped in the initrd alongside vfs.
+//! on failure it reports what went wrong. Shipped in the initial_ramdisk alongside vfs.
 
 const std = @import("std");
 const runtime = @import("runtime");
 
 pub fn main() void {
-    const u = runtime.unistd;
+    const u = @import("posix").unistd;
     const payload = "hello-vfs";
 
     // The VFS server may not have registered yet — retry open until it's up.

system/services/vfs/vfs.zig

@@ -1,4 +1,4 @@
-//! /sbin/vfs — the user-space VFS server. Shipped in the initrd, spawned as a
+//! /sbin/vfs — the user-space VFS server. Shipped in the initial_ramdisk, spawned as a
 //! ring-3 process, and reached by every other process through IPC (the `runtime`
 //! file API marshals open/read/write/stat/close into calls to this server's
 //! endpoint, published under the well-known `vfs` service id).
@@ -101,10 +101,10 @@ fn handle(message: []const u8, out: []u8) usize {
             if (off + n > nd.size) nd.size = off + n;
             return writeReply(out, .{ .status = 0, .len = @intCast(n) }, &.{});
         },
-        .stat => {
+        .status => {
             const of = openAt(request.node) orelse return fail(out);
-            const st = protocol.Stat{ .size = nodes[of.node].size, .kind = 0 };
-            return writeReply(out, .{ .status = 0, .len = @sizeOf(protocol.Stat) }, std.mem.asBytes(&st));
+            const st = protocol.FileStatus{ .size = nodes[of.node].size, .kind = 0 };
+            return writeReply(out, .{ .status = 0, .len = @sizeOf(protocol.FileStatus) }, std.mem.asBytes(&st));
         },
         .close => {
             if (request.node < opens.len) opens[@intCast(request.node)].used = false;