Phase 2d (ii): filesystem modification time (mtime)

Completes Phase 2: the FAT filesystem now stamps and reports a real modification
time, built on the Phase 2d(i) kernel wall-clock. This is the last stat field the
compiler's build cache needs to reason about (source vs cached output).

- on-disk.zig: fatToEpoch / epochToFatDateTime convert between the two 16-bit DOS
  date/time fields and Unix epoch seconds (UTC — FAT has no timezone). Host-tested
  round-trip + an absolute check (1577836800 == 2020-01-01).
- engine: a settable current_time_epoch that create/write stamp into the entry's
  write (and creation) date/time; Node/Listing gained an mtime decoded from those
  fields on read. Host test: a create stamps the mtime, read back through resolve
  and listEntry.
- vfs protocol FileStatus + runtime.fs.Attributes gained an mtime field; the fat
  server sets current_time_epoch from runtime.system.wallClock() per request and
  returns mtime from stat. The flat ramfs reports 0 (it has no timestamps).
- fat-test reads the created file's mtime through stat and checks it is a real
  current time, behind a new `fat-mtime` QEMU case.

Verified against the host: the guest stamped mtime 1783971676 while the host clock
was 1783971680 (boot+test lag) — the file's mtime is real current time. zig build,
zig build test (the epoch<->DOS conversions + the engine mtime test),
zig build check-fat-image, and a sequential QEMU sweep — fat-mount, fat-mutations,
fat-rename, fat-mtime, vfs, vfs-client-death, log-flush, orderly-shutdown,
initial-ramdisk, smoke, wall-clock, usb-storage — all green. mode/inode remain.

docs/zig-self-hosting.md

@@ -165,9 +165,9 @@ What the seam needs, and what danos already provides:
 | monotonic clock | `clock` syscall | none |
 | args / argv | SysV entry stack ([sysv.md](sysv.md)), `runtime.process.Init` | none |
 | stdout / stderr | `debug_write` today | wire fd 1/2 to a console **byte** stream |
-| **mkdir / unlink / rename / truncate** | — | **missing** in the VFS protocol *and* FAT engine |
-| **stat fields** | `{size, kind}` only | needs **mtime + inode + mode** (cache validity) |
-| **wall-clock / realtime** | monotonic only | needs an RTC/time service |
+| mkdir / unlink / rename / truncate | done — engine + VFS + `runtime.fs` (Phase 2) | — |
+| stat fields | `{size, kind, mtime}` | **mode / inode** still missing (cache validity) |
+| wall-clock / realtime | done — `wall_clock` syscall (CMOS RTC, Phase 2d) | — |
 | **environment variables** | `Init` has no env field | missing (can start empty) |
 | **cwd / chdir** | paths are absolute or bare | missing (no cwd anchor) |
 | **entropy / random** | — | missing (needed behind `vtable.random`) |
@@ -251,15 +251,19 @@ Because `std.fs`/`std.Io` have no per-OS branches, finishing this in `runtime.os
 lights up the whole file tower for the compiler at once. Environment can stay an empty
 map until the kernel populates a non-empty `envp`.
 
-**Status (Phase 2a–2c landed):** `truncate` (O_TRUNC, closing the boot-log stale-tail
+**Status — Phase 2 complete.** `truncate` (O_TRUNC, closing the boot-log stale-tail
 bug), `mkdir`, `unlink`, and `rename` are all wired through the FAT engine, the VFS
 protocol + router, and `runtime.fs` (`makeDirectory` / `remove` / `rename`) —
-host-tested and QEMU-tested (the `fat-mutations` + `fat-rename` cases make a directory,
-write+read a file in it, rename it, then remove it through the mount). `removeFile` and
-`rename` are LFN-aware; `rename` is same-directory + 8.3 (cross-directory and
-long-name-preserving rename are noted limitations). **Remaining Phase 2:** the richer
-`stat` — mtime/mode — which needs **wall-clock** (a kernel RTC read behind a syscall,
-consistent with time being a kernel concern), the natural next kernel-side step.
+host-tested and QEMU-tested (`fat-mutations` + `fat-rename` make a directory, write+read
+a file in it, rename it, then remove it through the mount). `removeFile` and `rename`
+are LFN-aware; `rename` is same-directory + 8.3 (cross-directory and long-name-
+preserving rename are noted limitations). Wall-clock is now a kernel syscall
+(`wall_clock`, a CMOS-RTC read anchored to the monotonic clock), and the FAT engine
+stamps and reports **mtime** — `stat` / `runtime.fs.Attributes` carry a real
+modification time (the `fat-mtime` case reads it back within seconds of the host clock).
+The remaining `stat` fields, `mode`/`inode`, are deferred (not needed until the
+compiler's cache layer wants them). **Everything past here is gated on Phase 0 (the
+fork):** the `runtime.os` seam, `cwd`, stdio-as-fds, and the compiler bring-up.
 
 ### Phase 3 — Single-threaded, self-linked compiler bring-up