runtime: consolidate the device-manager hello into runtime.device_manager

Every supervised driver owes the device manager a hello at startup, and
the retry-lookup-call-check for it had been copied into five drivers:
usb.helloManager (misfiled in the USB client) plus hand-rolled twins in
display, virtio-gpu, pci-bus, and usb-xhci-bus.

Extract it once as a runtime client, runtime.device_manager.hello(role,
device_id) ?Handle — returns the manager endpoint (bus drivers keep it to
report children through), null when there is no manager or it refused the
handshake, and logs the outcome itself so each call site is one line.

Also correct two roles while collapsing their calls: virtio-gpu and the
display driver each claim one PCI function and report no children, so they
are Role.device, not Role.bus. The manager ignores role today, so this is
cosmetic, but it matches the protocol's own definition (bus = reports
children via child_added).

Behavior-preserving otherwise: pci-bus and usb-xhci-bus move their hello
logging from raw serial writes to std.log, which the kernel renders with
the same "<path>: " prefix, so driver-restart still matches
"usb-xhci-bus: hello acknowledged". zig build clean; 8 QEMU cases pass
(driver-restart, pci-scan, usb-hid, usb-storage, virtio-gpu,
display-reattach, device-list, device-manager).

system/drivers/virtio-gpu/virtio-gpu.zig

@@ -23,7 +23,6 @@ const system = runtime.system;
 const ipc = runtime.ipc;
 const dp = runtime.display_protocol;
 const sp = runtime.scanout_protocol;
-const dm = runtime.device_manager_protocol;
 const vp = @import("virtio-pci.zig");
 const vg = @import("virtio-gpu-protocol.zig");
 
@@ -400,9 +399,10 @@ fn initialise(endpoint: ipc.Handle) bool {
     std.log.info("scanout {d}x{d} online", .{ current_width, current_height });
 
     // Hello the device manager so it counts us as up (and does not stop us at the hello
-    // deadline). A restarted instance re-hellos here and re-announces below — the compositor
-    // re-attaches to the fresh scanout (V6).
-    helloManager();
+    // deadline). Role: device — we claim one PCI function and serve its scanout; we report
+    // no children. A restarted instance re-hellos here and re-announces below — the compositor
+    // re-attaches to the fresh scanout (V6). Best-effort: standalone bring-up has no manager.
+    _ = runtime.device_manager.hello(.device, device_id);
 
     // Read the monitor's EDID (best-effort, when the device offers it) — the mode list a real
     // driver derives from it; we log the preferred mode and keep our fixed offered list.
@@ -513,31 +513,6 @@ fn presentFull() bool {
     return true;
 }
 
-/// Hello the device manager (role: bus — we own a PCI function, though we report no children):
-/// the handshake that marks us up so the manager doesn't stop us at the hello deadline, and
-/// (as a supervised driver) restarts us if we die. Best-effort: without a manager we still run.
-fn helloManager() void {
-    var tries: u32 = 0;
-    const manager = while (tries < 100) : (tries += 1) {
-        if (ipc.lookup(.device_manager)) |h| break h;
-        system.sleep(20);
-    } else {
-        std.log.info("no device manager to hello", .{});
-        return;
-    };
-    const hello = dm.Hello{ .role = @intFromEnum(dm.Role.bus), .device_id = device_id };
-    var reply: [dm.reply_size]u8 = undefined;
-    const n = ipc.call(manager, std.mem.asBytes(&hello), &reply) catch {
-        std.log.info("hello call failed", .{});
-        return;
-    };
-    if (n < dm.reply_size or std.mem.bytesToValue(dm.HelloReply, reply[0..dm.reply_size]).status != 0) {
-        std.log.info("hello refused", .{});
-        return;
-    }
-    std.log.info("hello acknowledged", .{});
-}
-
 /// Announce the scanout to the display service so it upgrades off the GOP framebuffer: hand it
 /// the shared surface as a capability plus the geometry. Best-effort and non-fatal — without a
 /// display service (the standalone virtio-gpu bring-up test) the driver is still a valid