fix: one VRAM-aware buffer budget for every GPU upload path

max_buffer_size is an API validation limit, not physical VRAM. NVIDIA
reports several GB of it on a 2 GB card, so sizing a chunk from it
produces buffers larger than the whole device. That is the same bug as
#203 (mesh_gpu), #358 (face3d_gpu) and the block-wire vertex buffer:
rediscovered three times because each upload path spelled the budget out
for itself.

mesh_gpu.rs was the only site that clamped the result. Move that clamp
into src/scene/pipeline/gpu_budget.rs and route every allocating path
through it, so a new upload path cannot reintroduce the mistake by
copying one of the unclamped expressions.

Five sites had no clamp at all: text_gpu (block-text instances),
wire_gpu (block-wire instances), and face3d_gpu (vertices, instances,
and upload_chunks).

Three behaviour changes worth noting:

  * Silhouette chunks were capped at a private 64 MiB constant and now
    use the shared 32 MiB budget.
  * The storage-hatch chunk limit was the minimum of two device limits,
    both of them validation figures; it is now also capped by the
    budget. The `*_fits` predicates next to it are genuine "would wgpu
    reject this" checks and are left alone.
  * mesh_gpu's instanced path used the unclamped ceiling to decide
    whether a mesh fits in a single buffer, which would still admit a
    multi-GB allocation. It now uses the clamped budget, so a few more
    meshes take the chunked path.

OCS_GPU_CHUNK_MIB overrides the cap. Raising it above the real VRAM is
the cheapest way to force an allocation failure and check that the
renderer degrades instead of aborting.

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

src/scene/pipeline/wire_gpu.rs

@@ -745,15 +745,10 @@ impl BlockWireGpu {
             // `mesh_gpu.rs` (#203) and the fill chunking in `face3d_gpu.rs`
             // (#358); the block-wire path was never converted, so a
             // block-heavy drawing produced one multi-hundred-MB buffer.
-            // `max_buffer_size` is an API validation limit, not physical VRAM
-            // (NVIDIA reports several GB on a 2 GB card), so clamp it the way
-            // `mesh_gpu.rs` already does.
-            let vertex_budget = ((device.limits().max_buffer_size as usize / 10) * 9)
-                .min(32 * 1024 * 1024);
-            let vsize = std::mem::size_of::<BlockWireVertex>();
             // Round down to a multiple of 6: each segment expands to six
             // vertices and must not straddle two chunks.
-            let max_verts = ((vertex_budget / vsize).max(6) / 6) * 6;
+            let max_verts =
+                super::gpu_budget::max_elements_grouped::<BlockWireVertex>(device, 6);
             let vertex_chunks: Vec<(wgpu::Buffer, u32)> = vertices
                 .chunks(max_verts)
                 .map(|chunk| {
@@ -810,9 +805,7 @@ impl BlockWireGpu {
                     })
                 })
                 .collect();
-            let max_instances = ((device.limits().max_buffer_size as usize / 10) * 9
-                / std::mem::size_of::<BlockWireInstance>())
-                .max(1);
+            let max_instances = super::gpu_budget::max_elements::<BlockWireInstance>(device);
             // Build each instance buffer once and reuse it across vertex
             // chunks, rather than re-uploading it per chunk.
             let instance_chunks: Vec<(wgpu::Buffer, u32)> = instances