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.

scripts/windows/package-windows-release.ps1

@@ -9,11 +9,18 @@ param(
     [Parameter(Mandatory=$true)][string]$PackageRoot,
     [string[]]$Architectures,   # default: every target in gpu-targets.json; a subset makes a smaller release
     [string]$ArchivePath,
+    [string]$RrToolsArchive,
+    [string]$FsrPayload,        # build_fsr_payload.py output: vkd3d-proton core + amdxc64 shim for the experimental FSR RR backend
     [switch]$LocalDevelopment
 )
 $ErrorActionPreference='Stop'
 . (Join-Path $PSScriptRoot 'gpu-target.ps1')
 $repo=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
+if (!$RrToolsArchive) { $RrToolsArchive=Join-Path $repo 'build/rr-portable-tools-v2.zip' }
+if (!(Test-Path -LiteralPath $RrToolsArchive -PathType Leaf) -or
+    (Get-FileHash -LiteralPath $RrToolsArchive -Algorithm SHA256).Hash -ne '297289a57a82142eb952479c99112b1c352a6753eb15bc6b2431bf686aed9b22') {
+    throw 'Pass -RrToolsArchive with the verified clean portable-tools v2 ZIP. Never package a used tool directory.'
+}
 if (!$GamePackagePrefix) { $GamePackagePrefix=Join-Path $repo 'dist/windows-gpu-coverage-game' }
 $PackageRoot=[IO.Path]::GetFullPath($PackageRoot)
 if($LocalDevelopment){
@@ -81,19 +88,56 @@ Stage (Join-Path $repo 'packaging/windows/d4r.ini') 'd4r/d4r.ini'
 Stage (Join-Path $repo 'tools/windows/dll-pins.txt') 'd4r/dll-pins.txt'
 Stage (Join-Path $repo 'tools/windows/gpu-targets.json') 'd4r/gpu-targets.json'
 if (!$inventoryStaged) { throw 'No d4r/d4r_gpu_inventory.exe in the inputs; d4r-check.ps1 needs it to query the GPU.' }
+if ($FsrPayload) {
+    # Experimental FSR RR backend: d4r-built vkd3d-proton (LGPL, source offer in SOURCE.txt) and d4r's amdxc64 shim.
+    # AMD's denoiser is never bundled; install.bat downloads the hash-pinned file when FSR is selected.
+    $FsrPayload=[IO.Path]::GetFullPath($FsrPayload)
+    $payloadManifest=Get-Content -LiteralPath (Join-Path $FsrPayload 'fsr-payload.json') -Raw | ConvertFrom-Json
+    if ($payloadManifest.kind -ne 'd4r-fsr-payload' -or $payloadManifest.amdDenoiserBundled) { throw 'Unsupported FSR payload manifest.' }
+    foreach ($property in $payloadManifest.files.PSObject.Properties) {
+        $file=Join-Path $FsrPayload $property.Name
+        if ((Get-FileHash -LiteralPath $file -Algorithm SHA256).Hash -ne $property.Value) { throw "FSR payload file changed: $($property.Name)" }  # -ne ignores case
+    }
+    foreach ($name in @('d4r_vkd3d_core.dll','amdxc64.dll')) { Stage (Join-Path $FsrPayload "fsr/$name") "d4r/fsr/$name" }
+    Stage (Join-Path $FsrPayload 'SOURCE.txt') 'd4r/fsr/SOURCE.txt'
+    foreach ($license in Get-ChildItem -LiteralPath (Join-Path $FsrPayload 'licenses') -File) { Stage $license.FullName "d4r/licenses/$($license.Name)" }
+    foreach ($patch in Get-ChildItem -LiteralPath (Join-Path $repo 'patches/vkd3d-proton-windows') -Filter '*.patch' -File) { Stage $patch.FullName "d4r/fsr/patches/$($patch.Name)" }
+}
 foreach ($optional in @(@{source='packaging/windows/WINDOWS_README.txt'; path='WINDOWS_README.txt'},
                          @{source='packaging/windows/install.bat'; path='install.bat'},
                          @{source='scripts/windows/install-dlss.ps1'; path='install-dlss.ps1'},
+                         @{source='tools/windows/install_dependencies.py'; path='install-dependencies.py'},
                          @{source='scripts/windows/d4r-check.ps1'; path='d4r/d4r-check.ps1'})) {
     $path=Join-Path $repo $optional.source
     if (Test-Path -LiteralPath $path) { Stage $path $optional.path }
 }
+Add-Type -AssemblyName System.IO.Compression,System.IO.Compression.FileSystem
+$toolZip=[IO.Compression.ZipFile]::OpenRead([IO.Path]::GetFullPath($RrToolsArchive))
+try {
+    $reader=[IO.StreamReader]::new($toolZip.GetEntry('rr-tools.json').Open())
+    try { $toolManifest=$reader.ReadToEnd() | ConvertFrom-Json } finally { $reader.Dispose() }
+    foreach ($entry in $toolZip.Entries) {
+        if ($entry.FullName.EndsWith('/')) { continue }
+        $name=$entry.FullName
+        if ($name -match '(^/|\\|:|(^|/)\.\.(/|$))') { throw "Unsafe portable-tools entry: $name" }
+        $relative='d4r/model-tools/'+$name
+        $destination=Join-Path $PackageRoot $relative
+        New-Item -ItemType Directory -Force (Split-Path $destination) | Out-Null
+        $inputStream=$entry.Open(); $outputStream=[IO.File]::Open($destination,[IO.FileMode]::CreateNew)
+        try { $inputStream.CopyTo($outputStream) } finally { $inputStream.Dispose(); $outputStream.Dispose() }
+        $digest=(Get-FileHash -LiteralPath $destination -Algorithm SHA256).Hash
+        if ($name -ne 'rr-tools.json' -and $digest -ne $toolManifest.files.PSObject.Properties[$name].Value) {
+            throw "Portable-tools hash mismatch: $name"
+        }
+        $files.Add(@{path=$relative; sha256=$digest; version=$null})
+    }
+} finally { $toolZip.Dispose() }
 # Shows players where the NGX core goes; a ZIP cannot carry an empty folder.
 $placeholder=Join-Path $PackageRoot 'd4r/ngx/PUT _nvngx.dll HERE.txt'
 New-Item -ItemType Directory -Force (Split-Path $placeholder) | Out-Null
 "Copy NVIDIA's _nvngx.dll into this folder. See WINDOWS_README.txt." | Set-Content -LiteralPath $placeholder -Encoding ASCII
 $files.Add(@{path='d4r/ngx/PUT _nvngx.dll HERE.txt'; sha256=(Get-FileHash -LiteralPath $placeholder -Algorithm SHA256).Hash; version=$null})
-if (Get-ChildItem -LiteralPath $PackageRoot -Recurse -File | Where-Object { $_.Name -in @('nvngx_dlss.dll','nvngx_dlssd.dll') -or ($_.Name -eq '_nvngx.dll' -and $_.DirectoryName -ne (Join-Path $PackageRoot 'd4r')) }) {
+if (Get-ChildItem -LiteralPath $PackageRoot -Recurse -File | Where-Object { $_.Name -in @('nvngx_dlss.dll','nvngx_dlssd.dll','amd_fidelityfx_denoiser_dx12.dll') -or ($_.Name -eq '_nvngx.dll' -and $_.DirectoryName -ne (Join-Path $PackageRoot 'd4r')) }) {
     throw 'Proprietary NVIDIA binaries must not be in the release.'
 }
 # Read by d4r-check.ps1: every shipped file's hash, so a damaged or mixed install is reported.