fix(hatch): radial gradients and correct gradient stop colours

A gradient hatch was drawn linear from the entity colour to its second
stop, so a red->yellow spherical fill came out as a pale linear wash. Two
fixes:
- Colour: start from the gradient's first stop, not the entity colour.
  hatch_model_from_dxf already baked stop-0 in; stop synced_hatch_models
  from clobbering it with the entity's resolved colour for gradient fills.
- Shape: spherical / hemispherical / curved gradient names now render as a
  radial fill (new shader mode 3, centred on the boundary with radius to the
  farthest vertex) instead of linear. Native and web shaders both updated.

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

src/scene/pipeline/hatch_gpu.rs

@@ -225,13 +225,21 @@ impl HatchGpu {
 
             let (mode, color2, grad_cos, grad_sin, grad_min, grad_range) = match &h.pattern {
                 HatchPattern::Solid => (1u32, [0.0; 4], 0.0, 0.0, 0.0, 1.0),
-                HatchPattern::Gradient { angle_deg, color2 } => {
-                    let r = angle_deg.to_radians();
-                    // Gradient projection range (proj_min / proj_range) —
-                    // computed at upload time, identical to per-hatch path.
-                    let (gmin, gmax) = boundary_projection_range(&h.boundary, r);
-                    let grange = (gmax - gmin).max(1.0);
-                    (2u32, *color2, r.cos(), r.sin(), gmin, grange)
+                HatchPattern::Gradient { angle_deg, color2, radial } => {
+                    if *radial {
+                        // Radial fill: the boundary is stored relative to its
+                        // centre (`world_origin`), so the centre is the local
+                        // origin; radius = the farthest boundary vertex. mode 3.
+                        let radius = radial_radius(&h.boundary);
+                        (3u32, *color2, 0.0, 0.0, 0.0, radius)
+                    } else {
+                        let r = angle_deg.to_radians();
+                        // Gradient projection range (proj_min / proj_range) —
+                        // computed at upload time, identical to per-hatch path.
+                        let (gmin, gmax) = boundary_projection_range(&h.boundary, r);
+                        let grange = (gmax - gmin).max(1.0);
+                        (2u32, *color2, r.cos(), r.sin(), gmin, grange)
+                    }
                 }
                 HatchPattern::Pattern(fams) => {
                     for fam in fams {
@@ -559,6 +567,18 @@ fn boundary_projection_range(boundary: &[[f32; 2]], theta: f32) -> (f32, f32) {
     (lo, hi)
 }
 
+/// Radius of a radial gradient — the distance from the boundary centre (the
+/// local origin, since vertices are stored relative to it) to the farthest
+/// vertex, so `t = 1` (the end colour) reaches the corners.
+fn radial_radius(boundary: &[[f32; 2]]) -> f32 {
+    boundary
+        .iter()
+        .filter(|p| p[0].is_finite() && p[1].is_finite())
+        .map(|p| (p[0] * p[0] + p[1] * p[1]).sqrt())
+        .fold(0.0_f32, f32::max)
+        .max(1.0)
+}
+
 // PatFamily is re-exported by hatch_model so we don't need to import
 // it explicitly anywhere else — but rust needs the type referenced to
 // confirm the layout assumption above.