fix(small crates): the proof lint now covers every first-party crate but one

Six crates were still unguarded, and all six are OURS — none vendored: pf-console-ui, pf-gpu,
punktfunk-tray, clients/windows, tools/display-disturb, wdk-probe. Two of them ship (the tray and
the Windows client), so "small" was about item count, not exposure.

Five are closed here. Only 17 of their 75 unsafe items actually lacked a proof — pf-gpu,
punktfunk-tray and display-disturb were already fully documented and needed nothing but the deny,
which is the good case: the convention was being followed, just not enforced.

The 17 that were missing are the usual Win32/COM shapes, and two were worth stating properly.
`clients/windows`'s `GetCurrentPackageFullName` is called with `len = 0` and no buffer — that is the
documented identity PROBE, which writes nothing, and reading it as a normal query would be a
mistake. `pf-console-ui`'s two `destroy_image_view` calls are the load-bearing ones: the comment
above one already argued that in-flight sampling of that slot ended two presents ago (the ring
alternates and the presenter waits its fence before each record), which is exactly the kind of
reasoning a `// SAFETY:` should carry and it was sitting there unlabelled.

Also fixes a real Windows-only clippy error this uncovered: `pf-gpu` had a
`#[cfg(target_os = "windows")]` fn AFTER its `mod tests`, tripping `items_after_test_module`. It
never fired on Linux (the item does not exist there) and no CI job clippies pf-gpu on Windows, so it
sat unseen. Moved above the test module.

Remaining: `wdk-probe` (26 items) alone, and only because it needs the WDK to build — .47 cannot,
so nothing here can verify a deny on it.

Verified: Linux .21 fmt + both CI clippy steps rc=0; Windows .47 the four Windows-relevant crates at
`-D warnings` rc=0.

clients/windows/src/gpu.rs

@@ -10,6 +10,8 @@ use windows::Win32::Graphics::Dxgi::{CreateDXGIFactory1, IDXGIAdapter, IDXGIFact
 
 /// The adapter's human-readable description.
 fn adapter_name(adapter: &IDXGIAdapter) -> String {
+    // SAFETY: a read-only COM call on the live `adapter` borrow, filling a descriptor returned by
+    // value; `&IDXGIAdapter` is a reference-counted wrapper, so the borrow IS the liveness.
     unsafe {
         adapter
             .GetDesc()
@@ -24,12 +26,16 @@ fn adapter_name(adapter: &IDXGIAdapter) -> String {
 
 /// Every DXGI adapter, in enumeration order.
 fn all_adapters() -> Vec<IDXGIAdapter> {
+    // SAFETY: DXGI factory creation takes no pointer and returns an owned factory or an error,
+    // matched on below before anything uses it.
     let factory: IDXGIFactory1 = match unsafe { CreateDXGIFactory1() } {
         Ok(f) => f,
         Err(_) => return Vec::new(),
     };
     let mut v = Vec::new();
     let mut i = 0u32;
+    // SAFETY: a COM call on the live factory above; it takes an index and yields an owned adapter,
+    // and the `Ok` pattern is what proves one came back.
     while let Ok(a) = unsafe { factory.EnumAdapters1(i) } {
         i += 1;
         if let Ok(a) = a.cast::<IDXGIAdapter>() {
@@ -54,6 +60,7 @@ pub fn adapter_names() -> Vec<String> {
     for a in all_adapters() {
         let desc1 = a
             .cast::<windows::Win32::Graphics::Dxgi::IDXGIAdapter1>()
+            // SAFETY: a read-only COM call on the adapter just cast, filling a descriptor by value.
             .and_then(|a1| unsafe { a1.GetDesc1() })
             .ok();
         let name = adapter_name(&a);