TL;DR: Add an experimental FSR Ray Regeneration backend on Windows, run the K

network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.

Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling

FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
  compose compute shaders. They run AMD's FidelityFX denoiser
  (amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
  vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
  patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
  backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
  runs an internal Super Sampling stage (feature 1) to upscale. If SR is
  unavailable and output != render size, the frame fails; it is never
  returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
  FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
  matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
  compile script.

Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
  because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
  (VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
  intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
  D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
  replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
  longer require near2rnd == out2rnd. Both values must still be in (0, 1].

K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
  (D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
  its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
  wave could overwrite its hb rows while a slower wave still read them for a
  later head, giving rare wrong results on gfx1101 (enc0 outputs differing
  between identical launches).

Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
  install_dependencies.py to install pinned NVIDIA dependencies with staged,
  hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
  on some synthetic runs, but player temporal exactness is unresolved.

Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
  benchmark_k_hip, build_capture_runtime, test_k_model and the
  zluda-k-output-capture patch. Captured weights and models are private
  local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
  prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.

Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
  rr-model-cache docs. Add windows-parity-handoff.md and
  windows-parity-continuation-prompt.md.

tools/windows/rr_native_backend.cpp

@@ -81,6 +81,7 @@ struct Backend::Impl {
             offset = plane.offset + plane.pitch * layout.rh;
         }
         layout.outputOffset = (offset + 511) & ~VkDeviceSize(511);
+        layout.outputPitch = (VkDeviceSize(layout.ow) * 16 + 255) & ~VkDeviceSize(255);
         layout.bytes = layout.outputOffset + layout.outputPitch * layout.oh;
     }
     void dispatch() {
@@ -151,8 +152,8 @@ struct Backend::Impl {
     }
     void validate_frame(const Snapshot& frame) {
         if (failed) throw std::runtime_error("Native RR backend is poisoned after failed submission");
-        if (frame.renderWidth != layout.rw || frame.renderHeight != layout.rh)
-            throw std::runtime_error("Dynamic RR render extent requires engine reconfiguration");
+        if (frame.renderWidth < 64 || frame.renderHeight < 64 || frame.renderWidth > creation.width || frame.renderHeight > creation.height)
+            throw std::runtime_error("RR render extent must be at least 64 and within creation geometry");
         if (frame.resources[Snapshot::Exposure]) throw std::runtime_error("RR exposure texture is not implemented");
         if (frame.exposureScale != 1 || frame.depthType || frame.normalsType || frame.roughnessType || frame.diffuseType || frame.specularType)
             throw std::runtime_error("RR guide encoding or exposure scale requires conversion");
@@ -170,12 +171,13 @@ struct Backend::Impl {
                 // D3D12 requires whole-subresource copies for depth-stencil.
                 // The copied subresource is depth plane 0, never stencil.
                 if ((desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL) &&
-                    (frame.origins[i][0] || frame.origins[i][1] || layout.rw != desc.Width || layout.rh != desc.Height))
+                    (frame.origins[i][0] || frame.origins[i][1] || frame.renderWidth != desc.Width || frame.renderHeight != desc.Height))
                     throw std::runtime_error("RR depth-stencil requires a full depth-plane rectangle");
             }
-            const uint32_t width = i == Snapshot::Output ? layout.ow : layout.rw;
-            const uint32_t height = i == Snapshot::Output ? layout.oh : layout.rh;
-            if (desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D || (i == Snapshot::Output && desc.Format != DXGI_FORMAT_R16G16B16A16_FLOAT) || desc.SampleDesc.Count != 1 || desc.DepthOrArraySize != 1 ||
+            const uint32_t width = i == Snapshot::Output ? layout.ow : frame.renderWidth;
+            const uint32_t height = i == Snapshot::Output ? layout.oh : frame.renderHeight;
+            if (desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D || (i == Snapshot::Output &&
+                desc.Format != DXGI_FORMAT_R16G16B16A16_FLOAT && desc.Format != DXGI_FORMAT_R32G32B32A32_FLOAT) || desc.SampleDesc.Count != 1 || desc.DepthOrArraySize != 1 ||
                 frame.origins[i][0] > desc.Width || width > desc.Width - frame.origins[i][0] ||
                 frame.origins[i][1] > desc.Height || height > desc.Height - frame.origins[i][1])
                 throw std::runtime_error("Unsupported native RR texture format or subrect");
@@ -187,6 +189,17 @@ struct Backend::Impl {
     }
     void evaluate(ID3D12CommandQueue* q, const Snapshot& frame, const std::array<ResourceAccess, Snapshot::Count>& access) {
         validate(q, frame, access); dispatch();
+        // Any mutation below may invalidate descriptors or engine bookkeeping;
+        // a failed reconfiguration must never reuse a partially rebuilt engine.
+        failed = true;
+        if (frame.renderWidth != layout.rw || frame.renderHeight != layout.rh) {
+            if (pending) throw std::runtime_error("RR resize requires retired GPU work");
+            layout.rw = frame.renderWidth; layout.rh = frame.renderHeight;
+            // Keep creation-sized packet pitches/offsets and imported fence.
+            // Rebuild only size-dependent views/history, retaining model data.
+            replay->resize();
+            std::fprintf(stderr, "D4R_RR_RESIZE render=%ux%u history_reset=1 model_reused=1 packet_reused=1\n", layout.rw, layout.rh);
+        }
         for (size_t i = 0; i < layout.planes.size(); ++i) {
             const auto resource = resource_index(i);
             layout.planes[i].enabled = frame.resources[resource] != nullptr;
@@ -195,6 +208,10 @@ struct Backend::Impl {
             replay->configure(i, format.format);
             layout.planes[i].format = format.format; layout.planes[i].bytes = format.bytes;
         }
+        const auto outputFormat = resource_desc(frame.resources[Snapshot::Output].Get()).Format;
+        layout.outputBytes = outputFormat == DXGI_FORMAT_R32G32B32A32_FLOAT ? 16 : 8;
+        layout.outputFormat = layout.outputBytes == 16 ? VK_FORMAT_R32G32B32A32_SFLOAT : VK_FORMAT_R16G16B16A16_SFLOAT;
+        replay->configureOutput();
         // Recording mutates engine upload/history bookkeeping. Any later error
         // requires recreation, even if no GPU submission has started yet.
         failed = true;
@@ -222,7 +239,7 @@ struct Backend::Impl {
         auto* output = frame.resources[Snapshot::Output].Get();
         texture_copy_barrier(consumer.Get(), output, access[Snapshot::Output], true, false);
         auto source = rr_bridge::D3D12Frames::placed(shared.Get(), layout.outputOffset, layout.outputPitch,
-            DXGI_FORMAT_R16G16B16A16_FLOAT, layout.ow, layout.oh);
+            outputFormat, layout.ow, layout.oh);
         auto dest = rr_bridge::D3D12Frames::texture(output);
         consumer->CopyTextureRegion(&dest, frame.origins[Snapshot::Output][0], frame.origins[Snapshot::Output][1], 0, &source, nullptr);
         texture_copy_barrier(consumer.Get(), output, access[Snapshot::Output], true, true);