mbo/hash: redesign dumbo-64 into a compact single-lane MUM hash (40 -> 188/188, 2-3x faster)

[helly25]

Rebuilds the legacy dumbo hash the measured way, addressing both problems the review flagged: silly constants and a slow multi-op core. Lands clean at SMHasher3 188/188.

Result

• SMHasher3: FAIL 40/188 -> PASS 188/188 (all three in-house hashes now clean).
• ~2-3x faster for >=8 B; the fastest hash in the suite for 7-8 B; strong (not merely reactive) avalanche.

What changed

• Constants: silly (6571, 17, 193, 104729) -> nothing-up-my-sleeve (golden ratio + sqrt-prime fractions).
• Core: the multi-op per-4-byte step -> one Mul128Fold64(word ^ kWord, state ^ kState) MUM step over 8-byte words. Both operands state/data dependent -> product is quadratic; a constant multiplier is linear and fails collisions/distribution no matter the constant.
• Finalizer: a two-multiply widening avalanche that keeps BOTH halves of the first product and mixes them, with the seed injected into a product operand (dumbo is single-lane, so a seed folded only at init reaches the finalizer weakly mixed for zero-data keys -> SeedZeroes; injecting it at finalize makes the output quadratic in the seed).
• Length folded at the end (folding it at init let a single low bit cancel a length delta and collide 1-bit with all-zero keys).
• Loads: shared endian-safe Load64/LoadTail -- no raw memcpy, no signed-char bug, const-eval == runtime on every target (incl. cross/big-endian).
• Deliberately minimal next to mumbo: one accumulator, one 8-byte word/step, no small-key switch, no lanes, no streaming, no 128-bit form.

Measured design iterations (in README)

legacy 40/188 -> v1 (non-widening, 132/188, exposes the constant-multiplier linearity) -> v2 (MUM core, 186/188, residual SeedZeroes) -> v3 (seed-at-finalize, 188/188).

Tradeoffs (documented)

• Values changed (dumbo is not stable across versions); plugin verification re-baked.
• Serial single accumulator -> degrades on large keys (far less than legacy: 256 B 68.7 -> 31.8 ns).
• The two-multiply finalizer is ~0.15-0.35 ns slower on tiny keys than an fmix64 would be (still fastest at 7-8 B).
• Loop micro-opts (end-pointer ptr < limit, [[likely]]/[[unlikely]]) were measured and rejected: the loop is latency-bound on the serial MUM chain, so the leaner form is off the critical path (clean A/B showed no difference).

Docs

• README quality tables (dumbo now PASS 188/188), a "dumbo: the measured design iterations" narrative, perf columns refreshed on the same rig (other algorithms' verified run preserved; cross-platform dumbo row is CI-sourced and refreshes on the next main CI run).

hash_test green (avalanche + seed-avalanche now asserted strong, distribution, structured-key distinctness, const-eval == runtime).