ITERATE-2.V: scheduler priority aging closes 18-day AUDIT-049 wedge

Priority aging in xenia-cpu/scheduler.rs:pick_runnable
(effective_priority = base + age_bonus(now_round - last_run_round),
capped at +31, AGING_ROUNDS_PER_BONUS=1). Strict-priority was parking
priority=0 threads behind CPU-bound priority=15 audio mixer
(sub_824D1328 guest spinwait at PC=0x824d1404 on CPU5). Aging
eventually picks the starved thread, breaking the producer-consumer
cycle that caused 5-tid wedge at PC=0x824ac578 since AUDIT-049 (10 May).

Cascade observed: tid=13 clean exit; events 121K -> 13M (107x); last
host_ns 767ms -> 51,011ms (66x); 8 new threads spawn; VdSwap 1 -> 2.

Complete two-day iterate sequence (2026-05-27 -> 2026-05-28):
- 2.F: VdSwap drain timeout 900ms -> 1ms (xenia-gpu/handle.rs); 876x
       perf win on VdSwap kernel callback
- 2.H: vA0000000 physical heap bucket added (state.rs, exports.rs);
       ctx_ptrs now in 0xA0000000-0xBFFFFFFF range matching canary
- 2.L: Phase-A diff harness categorized [return_value mismatch],
       [status mismatch], [args_resolved.path mismatch] tags
       (tools/diff-events/diff_events.py); closes reading-error #41
       (silent test-harness state leak invalidating trace diffs)
- 2.M: always-on exit-thread-state.json sibling to Phase-A JSONL
       (event_log.rs + xenia-app/main.rs); closes reading-error #42
       (Phase-A blind to blocked-forever waits)
- 2.Q: signal.match kernel instrumentation in NtSetEvent /
       NtReleaseSemaphore / KeSetEvent / KeReleaseSemaphore
       (exports.rs); emits target_handle + waiter_count + waiter_tids
- 2.T: wake.requested kernel instrumentation in wake_eligible_waiters
       (exports.rs); emits target_tid + transition + new_state
- 2.V: scheduler priority aging (xenia-cpu/scheduler.rs) [keystone]

Plus accumulated WIP from earlier May (contention_manifest,
phase_b_snapshot, xam/xaudio enhancements, analysis db, xex loader,
xenia-app main loop, etc.). Audit-runs/ artifacts remain untracked
per project convention.

Tests: 300 xenia-cpu / 227 xenia-kernel / 5 xenia-app / 19 xenia-path
/ 30+ smaller suites -- all PASS, 0 regressions. Determinism preserved
(2x cold runs bit-identical at 13,003,881 events post-2.V).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/xenia-gpu/src/handle.rs

@@ -390,7 +390,17 @@ impl GpuBackend {
                 // fires; the safety-net fallback warning fired twice for
                 // each Sylpheed run.
                 let target = s.mmio.cp_rb_wptr.load(Ordering::Acquire);
-                s.drain_until_wptr(mem, target, Duration::from_millis(900))
+                // GPUBUG-DRAIN-001 (iterate-2F, 2026-05-27): cap the inline
+                // drain at 1 ms so vd_swap does not block the main guest
+                // thread for ~900 ms per swap. Canary's `VdSwap_entry`
+                // returns in ~6.6 us — no synchronous drain. The 900 ms
+                // deadline parked tid=1 long enough to starve the post-swap
+                // worker fan-out at `sub_825070F0`, which in turn left
+                // tid=13's wait predicate unsatisfiable (wedge at
+                // PC=0x821CB1DC). Remaining packets stay queued in the
+                // ring; the next drain (next vd_swap or kernel-callback
+                // boundary) consumes them.
+                s.drain_until_wptr(mem, target, Duration::from_millis(1))
             }
             GpuBackend::Threaded(h) => {
                 let target_wptr = h.mmio.cp_rb_wptr.load(Ordering::Acquire);
@@ -560,7 +570,12 @@ impl GpuWorker {
                         // empty (rptr == wptr after modulo) or a packet
                         // returns `Idle`/`Blocked`.
                         self.system.sync_with_mmio();
-                        let deadline = Instant::now() + Duration::from_millis(900);
+                        // GPUBUG-DRAIN-001 (iterate-2F, 2026-05-27): cap at
+                        // 1 ms so the CPU's `recv_timeout(1s)` returns
+                        // promptly. Canary doesn't synchronously drain in
+                        // VdSwap; mirroring that frees tid=1 to spawn
+                        // post-swap workers in time.
+                        let deadline = Instant::now() + Duration::from_millis(1);
                         while self.system.is_ready(&*memory) {
                             if Instant::now() >= deadline {
                                 break;