feat: proper IPC-based boot — init loads servers from storage via IPC, VirtIO GPU driver

Complete microkernel boot pipeline: adapter loads only init + storage + display
from disk. Init bootstraps all other servers by reading binaries from the
storage server via IPC, parsing ELF, creating processes, mapping pages, and
spawning threads.

New syscalls:
- CreateEndpoint: userspace endpoint creation with full capability grant
- DebugPutchar: debug output to UART from userspace
- MapPage: cross-process page mapping (init loads binaries into children)
- SpawnThreadIn: spawn thread in another process via capability

Key fixes:
- Per-process L1 page tables for VPN[2]=0 (prevents cross-process corruption)
- Separate kernel_pt from page_tables[0] (init pid=0 overwrote kernel PT ref)
- Thread Running state set in switch_to_next (syscalls rejected without it)
- Pending IPC results applied during context switch
- SIE disabled during boot (timer can't preempt into unready processes)
- User heap VA starts at 0x40000 (avoids shared buffer at 0x30000)
- RequestPages maps at user VAs via per-process heap allocator

VirtIO GPU:
- Adapter probes for GPU device, initializes resource/scanout/backing
- Display server writes to mapped framebuffer, flushes via GPU virtqueue
- 640x480 BGRA framebuffer with transfer-to-host and resource-flush

Storage server:
- Userspace VirtIO block driver using pre-mapped MMIO and DMA pages
- FAT16 filesystem reader serving file-read requests via IPC
- Shared buffer protocol: init writes filename, storage writes file data

Echo app for IPC testing (adapter-loaded echo proved the pipeline end-to-end).

crates/domain/src/memory/process_memory.rs

@@ -1,11 +1,16 @@
+use types::address::VirtualAddress;
 use types::id::ProcessId;
 
 use crate::error::KernelError;
 
+const USER_HEAP_START: usize = 0x40000;
+const PAGE_SIZE: usize = 4096;
+
 pub struct ProcessMemory {
     process: ProcessId,
     page_count: usize,
     limit: usize,
+    next_heap_va: usize,
 }
 
 impl ProcessMemory {
@@ -14,9 +19,16 @@ impl ProcessMemory {
             process,
             page_count: 0,
             limit,
+            next_heap_va: USER_HEAP_START,
         }
     }
 
+    pub fn alloc_user_va(&mut self, pages: usize) -> VirtualAddress {
+        let va = self.next_heap_va;
+        self.next_heap_va += pages * PAGE_SIZE;
+        VirtualAddress::from_raw(va)
+    }
+
     pub fn process(&self) -> ProcessId {
         self.process
     }

crates/domain/src/syscall.rs

@@ -87,4 +87,17 @@ pub enum Syscall {
     Yield,
     Exit,
     Halt,
+    CreateEndpoint,
+    DebugPutchar { byte: u8 },
+    MapPage {
+        process: CapSlot,
+        src_va: VirtualAddress,
+        dst_va: VirtualAddress,
+        executable: bool,
+    },
+    SpawnThreadIn {
+        process: CapSlot,
+        entry: EntryPoint,
+        stack: StackPointer,
+    },
 }