Add SOG v3 loading and over-unity opacity rendering - #9873

A concern about where the plateau is stored. Decimated data will be the norm for large assets (most scenes over ~1M splats), and almost all of them will have some splats with opacity above 1. In our tests the merged opacity reaches about 20. So the plateau path will be on nearly all the time, and these become permanent costs:

• Extra splatPlateau work buffer stream: one more render target in the copy pass, and one more texture read in the quad VS, the projector, the shadow cull and pick.
• 9th projection cache word: entries grow from 32 B to 36 B, so most of them cross a 32-byte sector boundary. That nearly doubles the sectors the hybrid VS reads.
• Runtime detection: _checkOverUnity, the format change, the GSPLAT_OVERUNITY toggles, and the recompile plus work buffer recreation when the first decimated LOD arrives. Once most data is decimated, this mostly just adds a hitch.

The plateau fits in the existing storage instead, with no detection at all.

1. Work buffer: store the plateau in the alpha slot

When the plateau is above 1, the copy pass clamps the stored opacity to exactly 1 (color.w = min(color.w, 1.0) after encodePlateau). So for those splats the alpha slot holds no information, and D' can go there. The copy pass writes color.w = A <= 1 ? A : D', and each format encodes that value. The writeSplat signature doesn't change.

Large format (alpha is a half): the value is written as is, with no loss.

float getOpacity() {
    // ... loads and caches cachedColor as now
    return min(cachedColor.a, 1.0);
}

// call after getOpacity(), reads the same cached data
float getPlateau() {
    return max(cachedColor.a, 1.0);
}

Compact format (alpha is the top byte of dataTransformA.w): split the byte.

• Codes 0–191 are opacity.
• Codes 192–255 are opacity 1, with log2(D') in (0, 2]. That covers D' ≤ 4, so true opacity up to ~31.5; anything above is clamped.

// writeSplat
float a = color.a;
uint alphaBits = a > 1.0 ?
    191u + uint(clamp(log2(a) * 32.0 + 0.5, 1.0, 64.0)) :
    uint(clamp(a, 0.0, 1.0) * 191.0 + 0.5);

// read
float getOpacity() {
    uint code = cachedTransformA.a >> 24u;
    return code > 191u ? 1.0 : float(code) / 191.0;
}

float getPlateau() {
    uint code = cachedTransformA.a >> 24u;
    return code > 191u ? exp2(float(code - 191u) / 32.0) : 1.0;
}

Precision compared with the separate R8 (maximum error, true opacity 1–30):

Both are well under the error compact already has from its 8-bit log scales, up to ±8.6% in area. If low-opacity precision matters, a sqrt mapping over the 192 opacity codes would make faint splats more precise than they are today.

Non-decimated data never produces a plateau above 1, so the decode can always be compiled in. The plateau > 1.0 branch takes the same path for every vertex and fragment of a splat. That removes:

• the splatPlateau stream
• _checkOverUnity, _enableOverUnity and _compensationVersion
• the GSPLAT_OVERUNITY toggles
• the shadow material reconfiguration

compensation = false becomes a clamp in the copy pass. The clamp in the non-unified uncompressed.js stays.

One detail: in the large format, alpha lives in dataColor, which the color-only (SH update) pass rewrites, so that pass needs D' too. Either keep alpha with a color write mask in the color-only pass, or replace the 24-step bisection with a cheaper solve. Compact isn't affected, because its alpha isn't in dataColor.

2. Projection cache: stay at 8 words

The plateau can't share the cached alpha slot. That alpha includes the AA compensation and modifySplatColor, so plateau splats can be below 1 there. But v2 is redundant. The projector writes:

v1 = l1 * dir;
v2 = l2 * vec2f(dir.y, -dir.x);

So v2 is always v1 rotated by 90° and scaled by l2 / l1. Store that ratio and the plateau in v2's word:

// projector
projCache[base + 5u] = pack2x16float(vec2f(l2 / max(l1, 1e-6), plateau));

// hybrid VS
let ratioPlateau = unpack2x16float(projCache[base + 5u]);
let v2 = ratioPlateau.x * vec2f(v1.y, -v1.x);
let plateau = ratioPlateau.y;

The cost is one multiply, and v2 stays exactly perpendicular to v1. The same change applies to XR (word 6) and pick (word 5). Color, alpha and the user varyings stay as they are, and the stride stays at 32 B.

syncWithFormat() fix

I've extracted the syncWithFormat() fix into #9876 so it can land on its own, with a test that adds a stream through addExtraStreams(). It can be dropped from this PR once that merges.