runtime: std.log for every user binary — kernel-stamped attribution

library/runtime/log.zig wires std.log to the tagged ring: the root shim
installs std_options for every binary (programs may override), logFn
formats one line per record and emits it with its level via
debug_write — the payload no longer carries the process's name; the
kernel stamps identity structurally and the serial renderer prints the
'<binary path>: ' prefix, so the transcript keeps its shape.

Migrate every writeLine/logLine/log helper family (init, vfs, fat,
device-manager, acpi, pci-bus, ps2-bus x3, usb-hid x2, usb-storage,
usb-xhci-bus, virtio-gpu — 104 call sites) to std.log.info, dropping
the hand-written prefixes. A leveled record is a complete line by
contract (raw emissions may still build lines from pieces). Test
fixtures and the display/input services keep raw writes for now — their
ring records are attributed by the kernel regardless.

Harness regexes follow the renamed prefixes (usb-hid-keyboard,
discovery) and path-named restart lines.

system/services/vfs/vfs.zig

@@ -113,13 +113,6 @@ fn fail(out: []u8) usize {
     return writeReply(out, .{ .status = -1 }, &.{});
 }
 
-/// Format one whole log line and emit it in a single `debug_write`, so lines from
-/// concurrent processes can never land in the middle of it.
-fn writeLine(comptime fmt: []const u8, arguments: anytype) void {
-    var line: [96]u8 = undefined;
-    _ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return);
-}
-
 // --- mount routing ----------------------------------------------------------
 
 /// Forward an open under a mount to its backend and, on success, allocate a local
@@ -211,7 +204,7 @@ fn doMount(out: []u8, prefix: []const u8, backend: ipc.Handle) usize {
     for (&mounts) |*m| {
         if (m.used and std.mem.eql(u8, m.prefix[0..m.prefix_len], prefix)) {
             m.backend = backend;
-            writeLine("/system/services/vfs: remounted {s}\n", .{prefix});
+            std.log.info("remounted {s}", .{prefix});
             return writeReply(out, .{ .status = 0 }, &.{});
         }
     }
@@ -222,7 +215,7 @@ fn doMount(out: []u8, prefix: []const u8, backend: ipc.Handle) usize {
             @memcpy(m.prefix[0..l], prefix[0..l]);
             m.prefix_len = l;
             m.backend = backend;
-            writeLine("/system/services/vfs: mounted {s}\n", .{prefix[0..l]});
+            std.log.info("mounted {s}", .{prefix[0..l]});
             return writeReply(out, .{ .status = 0 }, &.{});
         }
     }
@@ -233,7 +226,7 @@ fn doUnmount(out: []u8, prefix: []const u8) usize {
     for (&mounts) |*m| {
         if (m.used and std.mem.eql(u8, m.prefix[0..m.prefix_len], prefix)) {
             m.used = false;
-            writeLine("/system/services/vfs: unmounted {s}\n", .{prefix});
+            std.log.info("unmounted {s}", .{prefix});
             return writeReply(out, .{ .status = 0 }, &.{});
         }
     }
@@ -252,7 +245,7 @@ fn releaseClientHandles(client: u32) void {
             released += 1;
         }
     }
-    if (released != 0) writeLine("/system/services/vfs: released {d} handle(s) for dead client {d}\n", .{ released, client });
+    if (released != 0) std.log.info("released {d} handle(s) for dead client {d}", .{ released, client });
 }
 
 /// Handle one request from `sender`; write the reply into `out`, return its length.