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

@@ -56,6 +56,21 @@ export namespace Crafter {
     struct DescriptorHeapWebGPU;
     #endif
 
+    // How a window hands finished frames to the display. Fifo waits for the
+    // display's refresh; it is the default and the one mode every surface
+    // has. Mailbox replaces a frame still waiting to be shown, so presenting
+    // never waits, which suits a window that updates on its own clock
+    // (Window::updateInterval). Immediate shows each frame at once and may
+    // tear. A mode the surface lacks falls back to Fifo, as does one whose
+    // swapchain the driver makes with more images than the frame loop's
+    // Window::numFrames (Mesa's Mailbox has at least four). In the browser
+    // the page presents the canvas and the mode has no effect.
+    enum class PresentMode {
+        Fifo,
+        Mailbox,
+        Immediate,
+    };
+
     struct Window {
         FrameTime currentFrameTime;
         std::uint32_t width; 
@@ -71,6 +86,17 @@ export namespace Crafter {
         Event<void> onResize;
         bool open = true;
         bool updating = false;
+        // Zero (the default): Update runs when the compositor's frame
+        // callback says the window is about to show a new frame, so it
+        // follows the display and stops while the window is hidden or
+        // minimized. Non-zero: Update runs on this clock instead, visible or
+        // not, for an app whose output goes somewhere besides the screen.
+        // Pair it with PresentMode::Mailbox so a present never waits on the
+        // display. Set it before StartUpdate. Native only: in the browser,
+        // requestAnimationFrame drives Update.
+        std::chrono::nanoseconds updateInterval{0};
+        // The mode SetPresentMode last asked for.
+        PresentMode presentMode = PresentMode::Fifo;
         // Currently-pressed raw key codes. The runtime stores raw platform
         // codes only (Win32 PS/2 scancode + extended bit; Wayland kernel
         // keycode). Cross-platform default bindings use `Key(CrafterKeys::X)`
@@ -156,6 +182,11 @@ export namespace Crafter {
 
         void StartUpdate();
         void StopUpdate();
+        // Makes the swapchain again with the new mode and fires onResize, as
+        // a resize does, so call it outside StartInit/FinishInit. The
+        // environment variable CRAFTER_PRESENT_IMMEDIATE overrides the mode,
+        // for benchmarks.
+        void SetPresentMode(PresentMode mode);
         void SetTitle(const std::string_view title);
         // The xdg app id, which the compositor matches to a .desktop file
         // for the icon, the task switcher and activation.
@@ -208,6 +239,21 @@ export namespace Crafter {
         #endif
 
         #ifdef CRAFTER_GRAPHICS_WINDOW_WAYLAND
+        // Wakes the event loop when `fd` becomes readable and calls
+        // `onReadable` from it, which must consume what made the descriptor
+        // readable, or the loop wakes again at once. For a socket, or an
+        // eventfd another thread signals, so new data can drive an Update
+        // right away (call Update from the callback) instead of waiting for
+        // the next one. StartSync's loop serves the descriptors of every
+        // window. Remove a descriptor before closing it.
+        void AddPollFd(int fd, std::function<void()> onReadable);
+        void RemovePollFd(int fd);
+        struct PollFd {
+            int fd;
+            std::function<void()> onReadable;
+        };
+        std::vector<PollFd> pollFds;
+
         float scale = 1.0f;
         bool configured = false;
         // Pending size from the most recent xdg_toplevel.configure, in
@@ -273,14 +319,28 @@ export namespace Crafter {
         // stay valid. Does NOT fire onResize — callers do that.
         void RecreateSwapchainAndImages();
 
-        // Save the current swapchain image (state after Render() returns) to
-        // a PNG file. Allocates a one-shot staging buffer + command buffer,
-        // copies image-to-buffer, waits idle, then writes PNG via stb. Useful
-        // for visual regression tests and screenshotting from headless code.
-        void SaveFrame(const std::filesystem::path& path);
+        // Saves the frame the next Render() draws to a PNG at `path`, for
+        // visual regression tests and screenshots: that Render copies the
+        // swapchain image into a readback buffer before presenting it, waits
+        // for the frame, and writes the file. The copy can't come later: a
+        // presented image belongs to the presentation engine until it is
+        // acquired again.
+        void CaptureNextFrame(std::filesystem::path path);
+        std::optional<std::filesystem::path> pendingCapture;
         static constexpr std::uint8_t numFrames = 3;
         VkSurfaceKHR vulkanSurface = VK_NULL_HANDLE;
         VkSwapchainKHR swapChain = VK_NULL_HANDLE;
+        // What the swapchain images were created for: STORAGE | TRANSFER_SRC,
+        // plus TRANSFER_DST where the surface allows it, so a pass can blit or
+        // clear into the image instead of only writing it from a shader.
+        VkImageUsageFlags swapchainUsage = 0;
+        // The mode the swapchain was made with: presentMode, unless the
+        // surface lacks it or CRAFTER_PRESENT_IMMEDIATE is set.
+        VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+        // The mode presentMode asks for made a swapchain with more images than
+        // numFrames once, so swapchains are FIFO until SetPresentMode is
+        // called again, rather than being made twice at every resize.
+        bool presentModeUnfit = false;
         VkFormat colorFormat;
         VkColorSpaceKHR colorSpace;
         // Supported composite-alpha mode for vulkanSurface. A surface property