Bug-fix: tame shafts / disc brightness so the scene doesn't blow out

The screenshot you sent shows the whole atmosphere whited-out with a
giant fuzzy sun blob. Root causes (with arithmetic, not hand-waving):

1. shafts EXPOSURE was 0.30. A pixel looking at the sun accumulates
   WEIGHT × Σ(DECAY^k) ≈ 0.78 × 9.92 ≈ 7.7 from the 16-sample radial
   blur. × 0.30 = 2.3 added to the scene additively, which then
   saturates through ACES tonemap and produces a giant white blob.
   Fix: EXPOSURE 0.30 → 0.08. A direct-at-sun pixel now gets ~0.6
   additive (clear glow without erasing underlying color).

2. Sun disc intensity was mix(2.2, 1.5, alt) — the disc itself was
   over 1.0 BEFORE the shafts added their contribution on top, so
   ACES could only clamp it to white. Fix: mix(1.4, 0.9, alt). Halo
   exponents trimmed to match.

3. Mask sun-cone was pow(dot, 8) — a fairly broad arc, so the
   shafts pass lit up too much of the sky. Tightening to pow(dot, 20)
   anchors rays to the actual sun direction.

Reverted: the fog `-view_dir` → `view_dir` change. I asserted that
was a bug without independent verification — keeping the original
direction until I can verify, per your "do not hallucinate" directive.
The washout was the shafts brightness, not the fog direction.

No features removed. Tests pass.

src/mask.wgsl

@@ -59,8 +59,10 @@ fn fs_mask(in: MaskOut) -> @location(0) vec4<f32> {
     let view_dir = normalize(world_far - camera.eye.xyz);
 
     let sun = sun_direction(scene_time());
-    // Tight cone around sun. pow exponent controls cone width.
-    let cone = pow(max(dot(view_dir, sun), 0.0), 8.0);
+    // Tighter cone around the sun (was pow 8 — broad arc, made the
+    // shafts pass light up too much of the sky). pow 20 keeps rays
+    // visually anchored to the actual sun direction.
+    let cone = pow(max(dot(view_dir, sun), 0.0), 20.0);
 
     let mask = is_sky * cone;
     return vec4<f32>(mask, mask, mask, 1.0);

src/shader.wgsl

@@ -168,18 +168,18 @@ fn sky_color(dir: vec3<f32>) -> vec3<f32> {
         sky = mix(sky, cloud_col, mask * (0.55 + 0.25 * day));
     }
 
-    // Sun disc + halo. The disc softens and spreads as the sun nears
-    // the horizon. Sharpness exponents reduced (was 800 at zenith,
-    // 160 at horizon — way too expensive on weak GPU / software
-    // rasterizers, and pow on big exponents is itself a slow op).
-    // 256/120 still reads as a crisp sun disc visually.
+    // Sun disc + halo. Intensity reduced (was 1.5–2.2 — pushed the
+    // disc above 1.0 which then ate the shafts additive on top,
+    // producing a huge saturated white blob through ACES). 0.9–1.4
+    // gives a crisp disc that stays inside the tonemap's linear
+    // range so detail survives the curve.
     let sun_col = sun_tint(sun);
     let cos_s = max(dot(dir, sun), 0.0);
     let alt = clamp(sun.y, 0.0, 1.0);
     let disc_sharpness = mix(120.0, 256.0, alt);
-    let disc_intensity = mix(2.2, 1.5, alt);
+    let disc_intensity = mix(1.4, 0.9, alt);
     let disc = pow(cos_s, disc_sharpness) * disc_intensity * smoothstep(-0.05, 0.05, sun.y);
-    let halo = pow(cos_s, mix(3.0, 5.0, alt)) * mix(0.35, 0.20, alt) * day;
+    let halo = pow(cos_s, mix(3.0, 5.0, alt)) * mix(0.22, 0.12, alt) * day;
     sky = sky + sun_col * (disc + halo);
 
     // Moon disc — opposite the sun, faint white, night only.

src/shafts.wgsl

@@ -51,14 +51,19 @@ fn vs_shafts(@builtin(vertex_index) idx: u32) -> ShaftsOut {
     return out;
 }
 
-// 32 → 16 samples. The earlier value was overkill — at quarter-res
-// with 16-step decay the rays still trace cleanly without banding,
-// and we cut the per-pixel cost in half. Compensating WEIGHT bump
-// keeps total intensity the same.
+// 32 → 16 samples. EXPOSURE drastically reduced (0.30 → 0.08) so
+// the rays read as subtle warm highlights through the atmosphere
+// rather than a giant white blob that saturates through ACES. The
+// previous value compounded with the bright sun disc and the
+// hemispheric ambient bump to push every pixel near the sun above
+// 1.0, which the tonemap then clamped to white. With EXPOSURE 0.08
+// a fragment looking *directly at* the sun receives an additive
+// shaft contribution of ~0.6, which reads as a glow without erasing
+// the underlying color.
 const N_SAMPLES: i32 = 16;
 const DECAY: f32 = 0.94;
 const WEIGHT: f32 = 0.78;
-const EXPOSURE: f32 = 0.30;
+const EXPOSURE: f32 = 0.08;
 
 @fragment
 fn fs_shafts(in: ShaftsOut) -> @location(0) vec4<f32> {