feat(cpp/gfx): GPU compute primitives for Monte Carlo (G1-G7)

Stack base de compute shaders OpenGL 4.3 para cargas Monte Carlo intensivas
en GPU. Reutiliza el patron de graph_force_layout_gpu (SSBO + compute) y se
integra con el resto del registry sin nuevos simbolos en gl_loader (todo lo
que se necesita ya estaba expuesto).

- gpu_ssbo: lifecycle de Shader Storage Buffer Objects.
- gpu_compute_program: compila compute GLSL 4.3 con preamble inyectable
  (mismo pattern de gl_shader::compile_fragment).
- gpu_dispatch: dispatch_1d/2d/3d con ceil(N/local) automatico + barrier
  helpers (storage, uniform, image, buffer_update, all).
- gpu_rng_glsl: PCG32 GLSL (uniform/normal/below) + SplitMix64 seed walkers
  para sembrar deterministicamente N walkers desde un master seed.
- gpu_histogram_1d: SSBO float[N] -> uint[nbins] via atomicAdd.
- gpu_histogram_2d: SSBO float[2N] xy-interleaved -> uint[nx*ny] +
  to_density helper para alimentar heatmap_cpp_viz.
- gpu_reduce: workgroup-shared sum/min/max/mean (local 256, partials CPU).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

cpp/functions/gfx/gpu_reduce.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "gfx/gpu_ssbo.h"
+
+namespace fn::gfx {
+
+enum class ReduceOp : int {
+    Sum = 0,
+    Min = 1,
+    Max = 2
+};
+
+// Reductor paralelo sobre SSBO float[N]. Usa workgroup-shared reduction.
+// El reductor mantiene un SSBO intermedio para guardar los partials por
+// workgroup (1 partial por workgroup). Tras dispatch, el ultimo paso es
+// una reduccion CPU-side de los partials (count tipico: N/256 — barato).
+//
+// Para distintos N hay que destruir y recrear (el partials_capacity esta
+// dimensionado al peor N pasado al constructor).
+struct GpuReduce {
+    unsigned int p_sum = 0;
+    unsigned int p_min = 0;
+    unsigned int p_max = 0;
+    unsigned int loc_count = 0;
+    unsigned int loc_count_min = 0;
+    unsigned int loc_count_max = 0;
+    Ssbo partials;        // float[max_groups]
+    int max_groups = 0;
+};
+
+// max_n_samples: cota maxima del N que se reducira (dimensiona el partials).
+// El local_size esta fijado a 256 internamente (workgroup tipico para
+// shared-mem reduction en consumer GPUs).
+GpuReduce gpu_reduce_create(int max_n_samples);
+
+// Ejecuta reduce con la operacion indicada. Devuelve el resultado escalar.
+// Bloquea (incluye readback de partials).
+//
+// samples: SSBO float[count] (binding 0 dentro del shader).
+// count: cuantos samples efectivos procesar (<= max_n_samples).
+float gpu_reduce_run(GpuReduce& r, ReduceOp op,
+                     const Ssbo& samples, int count);
+
+// Mean = sum / count. Helper que llama Sum y divide.
+float gpu_reduce_mean(GpuReduce& r, const Ssbo& samples, int count);
+
+void gpu_reduce_destroy(GpuReduce& r);
+
+} // namespace fn::gfx