Build voxel grids about 1.5x faster, with identical output

[Tobias-Fischer]

The camera runs made the voxel kernel the thing worth looking at: on a
saturated EVK4 it took 211 ms of a 50 ms window and was 80 % of loop time, so
the capture path was never what limited that loop.

Almost all of the cost turned out to be one line. Each event called both
floor() and ceil() and compared the results, which is two saturating
float-to-int conversions per event where one will do. age is filtered to
[0, window_ms] immediately above, so position lands in [0, bins - 1] and
is never negative --- and for a non-negative float as usize is the floor.
The fraction then carries everything the second call was for: it is zero
exactly when floor and ceil agreed, and when it is not, the upper bin is the
next one up, which is in range because a non-integer position is strictly below
bins - 1.

Measured on 2.8 M events over a 1280x720 grid, best of seven, old and new
kernels A/B'd in one process:

bins=1    61.0 ms -> 40.4 ms   1.51x
bins=5    96.8 ms -> 65.3 ms   1.48x
bins=9   109.0 ms -> 71.0 ms   1.54x

Output is bit-identical at every bin count --- the arithmetic is untouched, and
only the way the bin index is extracted from it changed. That was the point of
keeping the change this small: three other rewrites were tried and each of them
moved results in the last bits for less benefit than this one gives for none.

What the same benchmark says not to bother with, since the measurements cost
nothing to record and save someone repeating them:

• Bounds checks are free here. Replacing both indexed writes with
  get_unchecked_mut came out slower than the safe version, inside noise.
  The scatter is waiting on memory, not on checks.
• Accumulating bin-minor and transposing once at the end --- so an event's
  two contributions share a cache line instead of sitting plane_len apart
  --- was 15 % slower. The transpose costs more than the locality wins.
• Walking the four columns by index instead of through stream.iter() was
  slower too; the iterator optimises better than manual indexing does.
• Folding the divide into a constant and filtering ages in integer ticks is
  worth ~12 % on its own but nothing once truncation is in, and it does move
  the last bits. Not taken.

Rayon over per-thread accumulators reached a further 1.24x on two cores, but it
changes summation order (3.8e-5 on a cell here) and wants sizing on real
hardware, so it is left out of this change.

Co-Authored-By: Claude Opus 5 noreply@anthropic.com
Claude-Session: https://claude.ai/code/session_01Vj722xDQa64yshAdG3seYg