feat(host): vendor PyroWave + minimal Granite subset as crates/pyrowave-sys

Phase 0 of design/pyrowave-codec-plan.md — the opt-in wired-LAN ultra-low-
latency codec. Vendored at upstream 509e4f88 (API 0.4.0, Granite 44362775,
volk + vulkan-headers pins in PUNKTFUNK-VENDOR.txt), pruned to the 6.6 MB
the standalone no-renderer build needs; scripts/vendor-pyrowave.sh
reproduces the tree (a pin bump is protocol-affecting, plan §4.2).

build.rs drives the wrapper CMakeLists (static archives incl. a static
C-API lib upstream only ships shared) + bindgen over pyrowave.h; Linux and
Windows only, empty stub elsewhere (Apple gets a native Metal port, §4.7).
Offline-safe by construction: no network, no system lib, vendored Vulkan
headers — same model as the opus dep (flatpak builder has no network).

Phase-0 validation on .21 (RTX 5070 Ti, driver 610.43.03):
- upstream pyrowave-c-test + interop test (incl. dmabuf/DRM-modifier
  Vulkan<->Vulkan) pass, from the pristine AND the pruned tree
- GPU kernel times at ~1.6 bpp noise: encode/decode 0.090/0.042 ms @800p,
  0.146/0.067 @1080p, 0.226/0.103 @1440p, 0.477/0.201 @4K — order of
  magnitude under NVENC's 1-2 ms retrieve, CBR lands within ~100 B of
  target
- cargo test -p pyrowave-sys green (static link + API-version pin check)

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

crates/pyrowave-sys/vendor/pyrowave/Granite/vulkan/buffer_pool.cpp

@@ -0,0 +1,128 @@
+/* Copyright (c) 2017-2026 Hans-Kristian Arntzen
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define NOMINMAX
+#include "buffer_pool.hpp"
+#include "device.hpp"
+#include <utility>
+
+namespace Vulkan
+{
+void BufferPool::init(Device *device_, VkDeviceSize block_size_,
+                      VkDeviceSize alignment_, VkBufferUsageFlags usage_)
+{
+	device = device_;
+	block_size = block_size_;
+	alignment = alignment_;
+	usage = usage_;
+}
+
+void BufferPool::set_max_retained_blocks(size_t max_blocks)
+{
+	max_retained_blocks = max_blocks;
+}
+
+BufferBlock::~BufferBlock()
+{
+}
+
+void BufferPool::reset()
+{
+	blocks.clear();
+}
+
+BufferBlock BufferPool::allocate_block(VkDeviceSize size)
+{
+	BufferDomain ideal_domain = ((usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) != 0) ?
+			BufferDomain::Host : BufferDomain::LinkedDeviceHost;
+
+	BufferBlock block;
+
+	BufferCreateInfo info;
+	info.domain = ideal_domain;
+	info.size = size;
+	info.usage = usage;
+
+	block.buffer = device->create_buffer(info, nullptr);
+	device->set_name(*block.buffer, "chain-allocated-block");
+	block.buffer->set_internal_sync_object();
+
+	// Try to map it, will fail unless the memory is host visible.
+	block.mapped = static_cast<uint8_t *>(device->map_host_buffer(*block.buffer, MEMORY_ACCESS_WRITE_BIT));
+
+	block.offset = 0;
+	block.alignment = alignment;
+	block.size = size;
+	return block;
+}
+
+BufferBlock BufferPool::request_block(VkDeviceSize minimum_size)
+{
+	if ((minimum_size > block_size) || blocks.empty())
+	{
+		return allocate_block(std::max(block_size, minimum_size));
+	}
+	else
+	{
+		auto back = std::move(blocks.back());
+		blocks.pop_back();
+
+		back.mapped = static_cast<uint8_t *>(device->map_host_buffer(*back.buffer, MEMORY_ACCESS_WRITE_BIT));
+		back.offset = 0;
+		return back;
+	}
+}
+
+void BufferPool::recycle_block(BufferBlock &block)
+{
+	VK_ASSERT(block.size == block_size);
+
+	if (blocks.size() < max_retained_blocks)
+		blocks.push_back(std::move(block));
+	else
+		block = {};
+}
+
+BufferPool::~BufferPool()
+{
+	VK_ASSERT(blocks.empty());
+}
+
+BufferBlockAllocation BufferBlock::allocate(VkDeviceSize allocate_size)
+{
+	auto aligned_offset = (offset + alignment - 1) & ~(alignment - 1);
+	if (aligned_offset + allocate_size <= size)
+	{
+		auto *ret = mapped + aligned_offset;
+		offset = aligned_offset + allocate_size;
+		return { ret, buffer, aligned_offset, allocate_size };
+	}
+	else
+		return { nullptr, {}, 0, 0 };
+}
+
+void BufferBlock::unmap(Device &device)
+{
+	device.unmap_host_buffer(*buffer, MEMORY_ACCESS_WRITE_BIT);
+	mapped = nullptr;
+}
+}