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-Mesh.cppm

@@ -49,6 +49,12 @@ export namespace Crafter {
         // PREFER_FAST_BUILD are mutually exclusive, so `preference` selects
         // exactly one — allowUpdate is layered on top of whichever is set.
         bool allowUpdate = false;
+        // Set VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: an any-hit
+        // shader then runs at most once per primitive along a ray, which a
+        // shader that accumulates along it (transmittance through tinted
+        // glass) relies on. Without it the implementation may call it twice
+        // for one primitive. Can cost some trace speed.
+        bool noDuplicateAnyHit = false;
     };
 
     class Mesh {
@@ -75,12 +81,14 @@ export namespace Crafter {
         // has cleared — no longer pinned for the mesh's life. Between Builds the
         // handle is null; the next Build's Resize re-creates it.
         VulkanBuffer<std::byte, true> compressedStaging;
-        VkAccelerationStructureGeometryTrianglesDataKHR blasData;
-        VkAccelerationStructureGeometryKHR blas;
         VkAccelerationStructureKHR accelerationStructure = VK_NULL_HANDLE;
-        VkDeviceAddress blasAddr;
-        bool opaque;
+        VkDeviceAddress blasAddr = 0;
         // ─── Build-option / refit state ──────────────────────────────────
+        // The geometry's flags at the last (re)build: OPAQUE for triangles
+        // and for procedural geometry built opaque, plus
+        // NO_DUPLICATE_ANY_HIT_INVOCATION when asked for. Kept because an
+        // UPDATE must describe its geometry exactly as the build did.
+        VkGeometryFlagsKHR geometryFlags = VK_GEOMETRY_OPAQUE_BIT_KHR;
         // Flags the BLAS was last (re)built with — carried so Refit can
         // re-issue an identical-flags UPDATE build (the FAST_TRACE/FAST_BUILD
         // preference plus, when opted in, ALLOW_UPDATE).
@@ -95,6 +103,23 @@ export namespace Crafter {
         // Whether ALLOW_UPDATE was set on the last build, i.e. whether an
         // in-place refit is possible at all.
         bool allowUpdate = false;
+
+        Mesh() = default;
+        // Moving hands the BLAS over: the moved-from Mesh keeps no handle, so
+        // only the last owner releases it. Assigning queues the BLAS this one
+        // held, as the destructor would.
+        Mesh(Mesh&& other);
+        Mesh& operator=(Mesh&& other);
+        // Queues the BLAS for deferred deletion, ahead of the buffers it lives
+        // in (they queue themselves): a frame in flight may still trace it.
+        ~Mesh();
+
+        // A rebuild (any Build on a Mesh that already has a BLAS) queues the
+        // old handle for deferred deletion, since this command buffer or a
+        // frame in flight may still use it, and builds into the same storage
+        // after a barrier when the new BLAS fits, so blasAddr normally stays
+        // the same. A BLAS that outgrows its storage moves, so read blasAddr
+        // again after a rebuild.
         void Build(std::span<Vector<float, 3, 3>> verticies, std::span<std::uint32_t> indicies, VkCommandBuffer cmd, RTBuildOptions options = {});
         // GPU path: decompresses vertex (region 0) and index (region 1) streams
         // from asset.blob into vertexBuffer / indexBuffer using
@@ -126,7 +151,11 @@ export namespace Crafter {
         // and VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, its boxes laid out as
         // VkAabbPositionsKHR (`stride`, default sizeof(RTAabb) == 24), and the
         // caller must pipeline-barrier the producing writes (e.g. a compute
-        // dispatch) before the build on `cmd` reads them. The buffer's
+        // dispatch) before the build on `cmd` reads them, with
+        // VK_ACCESS_SHADER_READ_BIT at the acceleration-structure build stage:
+        // a build reads its geometry as a shader read, and the
+        // ACCELERATION_STRUCTURE access bits cover only the scratch and the
+        // acceleration structures themselves. The buffer's
         // lifetime is the caller's responsibility — it is never copied, so it
         // must outlive the build submitted on `cmd`. Everything else (opaque
         // bit, hit-group contract, instance wiring) matches the host-span
@@ -151,8 +180,8 @@ export namespace Crafter {
         // Dirty-range refit: same as Refit above, but only the contiguous block
         // of vertices in [dirtyVertexOffset, dirtyVertexOffset + dirtyVertexCount)
         // actually moved, so on the in-place UPDATE path only that sub-range is
-        // re-uploaded — host-write + flush + barrier (direct) or re-stage + copy
-        // (staged) scale with the moved vertices, not the whole array (#119). Use
+        // re-uploaded — the staged copy scales with the moved vertices, not the
+        // whole array (#119). Use
         // this for a deforming mesh that nudges a small, known window each frame.
         // `verticies` / `indicies` are still the *full* arrays (same contract and
         // topology rule as the full-span Refit — the index buffer is read only
@@ -229,6 +258,8 @@ export namespace Crafter {
     struct RTBuildOptions {
         RTBuildPreference preference = RTBuildPreference::FastTrace;
         bool allowUpdate = false;
+        // No effect here either; for API symmetry like the rest.
+        bool noDuplicateAnyHit = false;
     };
 
     class Mesh {