feat: windows on their own clock, deferred deletion for every handle owner, staged re-uploads, and RTPass push data

Window
- updateInterval runs Update on the window's own clock while the
  compositor sends no frame callbacks (hidden, minimized): the Wayland loop
  is a poll() loop, and the Win32 loop sleeps until the next update. Both
  read the interval each pass.
- SetPresentMode (FIFO, Mailbox, Immediate). A mode the surface lacks, or
  whose swapchain has other than numFrames images (Mesa's Mailbox has four),
  falls back to FIFO until the mode is set again.
- AddPollFd / RemovePollFd wake the Wayland loop on the app's descriptors.
- The swapchain has TRANSFER_DST where the surface allows it.
- CaptureNextFrame replaces SaveFrame: it records the copy in the frame,
  before the present, where SaveFrame read an image already presented. A
  frame unwound past before the write still frees the readback buffer.
- Inter-pass barriers on the swapchain image carry the access masks of the
  stages the passes use.

Deferred deletion (issue #101)
- VulkanBuffer, Mesh, VulkanShader, ComputeShader and PipelineRTVulkan hand
  their handles to the deletion queue from their destructors and moves, as
  a frame in flight may still use them; a static owner goes after the
  driver has torn down. VulkanShader and PipelineRTVulkan move and can't be
  copied; re-Load and re-Init queue the old pipeline.
- The queue and its mutex are never destroyed, and the queue takes handles
  from any thread; Device::frameCounter is atomic. Both the queue and the
  staging rings count frames as one window renders them (documented).
- DrainDeletions also lets every buffer's staging ring start over: without
  a Window nothing else reclaims either, so an app without one calls it
  after waiting for its work.

Meshes and buffers
- A Mesh rebuild queues the old acceleration structure and builds into the
  same storage after a barrier, so the BLAS address stays put when it fits.
  The refit and rebuild barriers cover compute ray queries too.
- RTBuildOptions::noDuplicateAnyHit. Mesh::geometryFlags replaces opaque,
  and the refit and rebuild fallbacks keep the flags.
- A re-upload into a buffer a frame in flight may read (UploadDeviceLocal
  of the same size, UploadDeviceLocalRange) copies on the GPU, after those
  reads, through a per-frame staging ring; on ReBAR it used to write the
  buffer in place. Empty uploads record nothing.
- A compressed Mesh::Build that keeps its buffers decompresses into them
  after the reads of frames in flight, and the hit shaders and ray queries
  wait for the decompress as well as the BLAS build. Its vertex buffer
  takes a ranged refit's copies.
- Mesh move-assigns (queueing the BLAS it replaces), so it can be replaced
  in place or erased from a vector.
- VulkanBuffer::Create asks for a device address only for buffers with
  SHADER_DEVICE_ADDRESS usage, as vkGetBufferDeviceAddress requires; the
  others have address 0. UIRenderer::RegisterBuffer refuses those.
- Build inputs are synchronized as shader reads.

Other
- RTPass pushes the app's own push data and traces at an explicit size.
- DescriptorHeapVulkan hands freed slot ranges out again (they leaked), and
  keeps its free lists sorted.
- ImageVulkan's mip chain clamps each level to 1 texel: a non-square
  image's shorter side went to 0.
- VulkanShader throws on a missing file instead of failing in bad_alloc.
- CRAFTER_GRAPHICS_DEVICE picks the GPU by its number among the distinct
  GPUs Vulkan lists; anything but such a number is an error.
- The debug messenger prints info messages only with
  CRAFTER_GRAPHICS_VALIDATION set.
- Windows: the WinRT gamepad code moved to a C file (mingw-w64's WinRT
  headers don't compile as C++), -lcombase dropped, a reference leak fixed.
- project.cpp honours --local for Crafter.Event, Math and Asset, as Asset
  does for Math, and builds every test through one helper, projectArgs
  included.
- Tests: DebugMessengerSeverity, DeletionQueueThreads, DeviceSelection,
  HeapSlotReuse, MeshLifetime, MipChainNonSquare, PipelineLifetime,
  RTPassPushData, SwapchainTransferDst, UploadInFlight, VulkanBufferAddress,
  VulkanShaderLifetime, WindowUpdateClock; others extended.

Breaking: SaveFrame is CaptureNextFrame; Mesh::opaque is geometryFlags; a
buffer without SHADER_DEVICE_ADDRESS usage has no address; frameCounter is
std::atomic.

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

interfaces/Crafter.Graphics-Device.cppm

@@ -378,17 +378,30 @@ export namespace Crafter {
         // instead, tagged with the current frameCounter; ReclaimDeletions frees
         // an entry only once framesInFlight frames have elapsed, by which point
         // single-queue submission order guarantees all GPU work that could
-        // reference it has completed.
+        // reference it has completed. Destructors that own Vulkan handles
+        // (VulkanBuffer, Mesh, VulkanShader, ComputeShader, PipelineRTVulkan)
+        // queue them too: they can't know
+        // whether a frame in flight still uses the handle, and a static owner
+        // is destroyed after the driver and its layers have torn down, when no
+        // Vulkan call may run. An entry holds one kind of handle; the others
+        // stay VK_NULL_HANDLE.
         struct PendingDeletion {
             std::uint64_t retireAfter;   // frameCounter value at enqueue time
-            VkBuffer buffer;
-            VkDeviceMemory memory;
+            VkBuffer buffer = VK_NULL_HANDLE;
+            VkDeviceMemory memory = VK_NULL_HANDLE;
+            VkAccelerationStructureKHR accelerationStructure = VK_NULL_HANDLE;
+            VkShaderModule shaderModule = VK_NULL_HANDLE;
+            VkPipeline pipeline = VK_NULL_HANDLE;
         };
         // Monotonic recorded-frame index, bumped once per Window::Render. Not
         // the same as Window::frameCounter (which is per-window and also drives
         // the acquire-semaphore slot) — this one is global so Mesh/Device code
-        // can enqueue too, not just the window loop.
-        inline static std::uint64_t frameCounter = 0;
+        // can enqueue too, not just the window loop. Atomic: a destructor on
+        // another thread reads it as it queues. It counts frames as one
+        // window renders them: with several windows rendering, framesInFlight
+        // of its counts pass sooner than each window's frames in flight, so
+        // the deletion queue and the staging rings assume one window.
+        inline static std::atomic<std::uint64_t> frameCounter = 0;
         // = Window::numFrames; set at window init. The number of frames that
         // must elapse after an enqueue before the resource is safe to free.
         // Zero until set, which only makes ReclaimDeletions more eager — and it
@@ -397,18 +410,36 @@ export namespace Crafter {
         // A deque, not a vector: frameCounter is monotonic, so retireAfter is
         // non-decreasing down the queue and the entries ready to reclaim are
         // always a prefix. ReclaimDeletions pops that prefix off the front in
-        // O(ready) instead of walking and compacting the whole queue.
-        inline static std::deque<PendingDeletion> deletionQueue;
+        // O(ready) instead of walking and compacting the whole queue. Never
+        // destroyed: static owners queue their handles from their destructors
+        // at exit, and those may run after this queue's own destructor would.
+        inline static std::deque<PendingDeletion>& deletionQueue = *new std::deque<PendingDeletion>();
+        // Held by the calls below: handle owners go on whichever thread drops
+        // them (a loader's, say) while the render loop reclaims. Never
+        // destroyed, for the same reason as the queue.
+        inline static std::mutex& deletionMutex = *new std::mutex();
         // Tag {buffer, memory} for deletion after framesInFlight more frames.
         // A VK_NULL_HANDLE buffer is ignored (nothing to free).
         static void EnqueueDeletion(VkBuffer buffer, VkDeviceMemory memory);
+        // The same for an acceleration structure, a shader module and a
+        // pipeline. Queue an acceleration structure before the buffer it lives
+        // in: entries are freed in queue order. A VK_NULL_HANDLE is ignored.
+        static void EnqueueDeletion(VkAccelerationStructureKHR accelerationStructure);
+        static void EnqueueDeletion(VkShaderModule shaderModule);
+        static void EnqueueDeletion(VkPipeline pipeline);
         // Free every entry whose retire frame has been reached
         // (retireAfter + framesInFlight <= frameCounter). Call once per frame
         // after waiting that frame's fence.
         static void ReclaimDeletions();
-        // Free every queued entry unconditionally. Call only after a wait-idle
-        // (resize / teardown), when no in-flight GPU work can reference them.
+        // Free every queued entry unconditionally, and let every buffer's
+        // staging ring start over. Call only after a wait-idle (resize /
+        // teardown), when no in-flight GPU work can reference them. Without a
+        // Window nothing else reclaims them: an app that has none calls this
+        // after waiting for its work, or both only grow.
         static void DrainDeletions();
+        // How many DrainDeletions have run: the staging rings start over
+        // when it changes.
+        inline static std::atomic<std::uint64_t> drains = 0;
 
         // ─── Wayland key repeat ────────────────────────────────────────
         // TickKeyRepeats fires onRawKeyDown / onRawKeyHold / onTextInput on