feat(vulkan): run the compute/UI path without VK_EXT_descriptor_heap

Device::Initialize required twelve device extensions with no capability
check. Mesa Turnip (Adreno) lacks six of them: VK_EXT_descriptor_heap,
VK_KHR_shader_untyped_pointers, VK_EXT_device_fault and the three ray
tracing extensions. vkCreateDevice failed there, so not even a UI-only
program could start, although the UI path is compute-only and needs
nothing else that Turnip is missing.

The descriptor heap, ray tracing and device fault are now optional
groups, detected at start-up from the extension list and the feature
bits (Device::descriptorHeapSupported, rayTracingSupported,
deviceFaultSupported). Ray tracing needs the heap; on a device without
it the ray tracing entry points throw a message naming the cause.

Without the heap the same bindless slots live in one update-after-bind
descriptor set per frame, owned by DescriptorHeapVulkan: binding 0
storage images, 1 sampled images, 2 samplers, 3 storage buffers. Slot
allocation, the slot handles, UIDispatchHeader and the UIRenderer API
are unchanged; buffer slots simply stop being offset. Window::Render
binds that frame's set where it binds the heap, every compute pipeline
shares the heap object's pipeline layout, and push data travels as push
constants.

Each UI kernel is built twice from one source. ui-shared.glsl declares
its resources through UI_HEAP_* macros that expand to descriptor_heap
or, with CRAFTER_GRAPHICS_DESCRIPTOR_SETS defined, to set/binding.
<name>.comp.spv and <name>.comp.sets.spv ship side by side and
ComputeShader::Load picks one. The heap build of every shader is
byte-identical to before.

Breaking:
- ComputeShader::Load takes the heap as a second argument.
- DescriptorHeapVulkan is no longer copyable or movable.
- Custom UI shaders declare heap resources with the UI_HEAP_* macros
  and are registered twice in project.cpp (see the README).
- project.cpp uses Shader::defines and Shader::variant, so it needs a
  crafter-build that has them (Crafter.Build master, fe38cc1 or later).

Also:
- maintenance5 is enabled as a feature, not only as an extension:
  every VulkanBuffer already relied on VkBufferUsageFlags2CreateInfo.
- Barrier stage masks drop RAY_TRACING_SHADER on devices without ray
  tracing, and ImageVulkan::Create resolves its default consumer stage
  to COMPUTE_SHADER there.
- Window refuses a swapchain whose image count is not numFrames
  instead of writing past images[]. The limitation itself is #160.
- CRAFTER_GRAPHICS_NO_DESCRIPTOR_HEAP forces the fallback on a driver
  that has the heap, so it can be exercised on a desktop GPU.

Verified on an RTX 4090 in both modes under the validation layer, and
on a Fairphone 6 (Turnip, Adreno 810, postmarketOS), where the fallback
is the only path.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

interfaces/Crafter.Graphics-ComputeShader.cppm

@@ -9,17 +9,29 @@ export module Crafter.Graphics:ComputeShader;
 #ifndef CRAFTER_GRAPHICS_WINDOW_DOM
 import std;
 import :Device;
+import :DescriptorHeapVulkan;
 
 export namespace Crafter {
-    // Tier 1: thin compute-pipeline wrapper. Owns one VkPipeline created with
-    // VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT (no pipeline layout — the
-    // bindless heap supplies all bindings, push constants travel via
-    // vkCmdPushDataEXT). Use this to dispatch the four standard UI shaders
-    // and any user-authored compute shader that follows the ui-shared.glsl
-    // contract.
+    // Tier 1: thin compute-pipeline wrapper. Owns one VkPipeline. Use this to
+    // dispatch the four standard UI shaders and any user-authored compute
+    // shader that follows the ui-shared.glsl contract.
+    //
+    // The pipeline follows the device's binding model
+    // (Device::descriptorHeapSupported):
+    //   heap -> created with VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT and
+    //           no pipeline layout; the bindless heap supplies all bindings
+    //           and push constants travel via vkCmdPushDataEXT.
+    //   sets -> created from the shader's <name>.sets.spv build against the
+    //           heap object's shared pipeline layout; the bindless descriptor
+    //           set supplies the bindings and push constants travel via
+    //           vkCmdPushConstants.
     class ComputeShader {
     public:
         VkPipeline pipeline = VK_NULL_HANDLE;
+        // Sets mode only: the pipeline layout of the heap this shader was
+        // loaded against, needed again by vkCmdPushConstants. Not owned — it
+        // belongs to that DescriptorHeapVulkan. VK_NULL_HANDLE in heap mode.
+        VkPipelineLayout layout = VK_NULL_HANDLE;
 
         // NVIDIA descriptor-heap AS-read workaround (issue #15 / #7): set by
         // Load when this shader ray-queries the TLAS through the descriptor
@@ -38,14 +50,30 @@ export namespace Crafter {
         ComputeShader& operator=(ComputeShader&& other) noexcept;
         ~ComputeShader();
 
-        // Loads a SPIR-V compute shader from disk and creates a pipeline that
-        // uses the bindless descriptor-heap binding model.
-        void Load(const std::filesystem::path& spvPath);
+        // Loads a SPIR-V compute shader from disk and creates its pipeline.
+        //
+        // `spvPath` always names the descriptor-heap build (<name>.spv). On a
+        // device without the heap, the <name>.sets.spv build next to it is
+        // loaded instead, so the caller never branches on the binding model;
+        // a missing .sets.spv throws, naming the file.
+        //
+        // `heap` must already be Initialize()d and must be the heap assigned
+        // to Window::descriptorHeap for every frame this shader is dispatched
+        // in: in sets mode the pipeline is built against that heap's layout,
+        // and Window::Render binds that heap's descriptor set.
+        void Load(const std::filesystem::path& spvPath, DescriptorHeapVulkan& heap);
 
         // Bind, push constants (if any), dispatch. Caller computes group counts
         // and is responsible for any inter-dispatch barriers (UIRenderer::Dispatch
         // wraps this with the standard write-after-write barrier).
         //
+        // pushBytes should be a multiple of 4 (Vulkan requires it for both
+        // push mechanisms). On a device without the descriptor heap the
+        // payload travels as ordinary push constants, so it must also fit
+        // the device's maxPushConstantsSize (256 bytes on common drivers); a
+        // larger one throws std::length_error. Keep push blocks within that
+        // if the shader is meant to run on both binding models.
+        //
         // tlasAddress is the NVIDIA descriptor-heap AS-read workaround hook
         // (issue #15 / #7): a shader that ray-queries the TLAS through the
         // descriptor heap is rewritten to read its device address from a push