Fix mc interpolate canonical

[snowbldr]

Fix mcInterpolate: canonicalize argument order to avoid quantization-induced boundary edges

Fixes one of the bugs in #85.

The bug

Two adjacent marching-cubes cells share a cube edge, but they number that
edge with swapped endpoints — e.g. cube A's MC edge 1 is cube B's MC
edge 3 on their shared +X/−X face, with p1 and p2 reversed.

Algebraically the two interpolations are equal:

p1 + t·(p2 − p1)   ==   p2 + t'·(p1 − p2)     where t' = 1 − t

but in floating-point they can differ by ~1 ULP — the multiplications and
additions don't commute bit-exactly. The downstream vertex quantization
in mesh.go (int32(c · 1e4)) then lands the two near-equal results in
different buckets whenever the crossing sits near a 1e-4-aligned
coordinate. That's the typical case on axis-aligned box faces (e.g.
Y = 1.0 for a 6×2×2 box). The two cubes emit triangles whose shared
edge is recorded as two distinct quantized edges, and the watertightness
check counts both as boundary edges instead of cancelling.

For Box3D({6, 2, 2}, round=0.3) rendered via the octree at c=100,
this produced 4320 boundary edges on a shape that should be perfectly
watertight.

The fix

Sort (p1, p2) and (v1, v2) into a fixed lexicographic order at the
top of mcInterpolate:

if p2.X < p1.X ||
   (p2.X == p1.X && p2.Y < p1.Y) ||
   (p2.X == p1.X && p2.Y == p1.Y && p2.Z < p1.Z) {
    p1, p2 = p2, p1
    v1, v2 = v2, v1
}

Both cubes now evaluate the identical floating-point expression on the
shared edge, so the quantizer buckets them together and the boundary
edge cancels. After: 0 boundary edges at every tested resolution.

Tests

render/mc_interpolate_test.go pins a sweep across both renderers:

• Octree at c ∈ {50, 75, 100, 125, 150, 200}
• Uniform at c ∈ {50, 100, 125, 150}

on Box3D({6, 2, 2}, round=0.3) — the configuration that triggered the
4320-boundary-edge case before the fix. All zero on macOS.

Architecture-specific note

Same family as the earlier #84 issue: a borderline floating-point
ordering that flips on FMA / FTZ rounding differences. The bug was
visible on x86_64 and likely worse there than Apple Silicon because
FMA fusion changes which of the two cube interpolations rounds where.
The canonicalization removes the ordering ambiguity entirely, so both
architectures are equivalent after the fix.