feat(app): size the receptions card to what it holds, in steps

[khagele]

Closes #560

What was happening

The receptions card was ten lanes or nothing: 298px, a third of a 915px phone, whether it held
one reception or two hundred.

A full card did not even show ten. The playhead sat six lanes down with three lanes of padding
under it, and rxFade reached zero exactly on the card's own top lane. Ten receptions rendered
as six readable rows, one active row, and three blank lanes.

The curve

The height follows the content now, in the steps @khagele specified:

receptions	lanes	shows
0	header only	nothing
1, 2	1	the newest
3, 4, 5	3	all of them
6 to 9	5	the newest five
10 and up	10	the newest ten

Below six receptions the card shows everything it has; from six it caps, so the oldest roll off
the top rather than the card taking the screen.

Newest at the bottom, and the playhead where it was

The blank lanes were never the playhead's fault. They came from the padding under the last row,
so that is what goes. With no padding there the browser clamps the follow-scroll three lanes
short of the playhead, and that clamp parks the newest reception on the bottom lane while the
playhead stays six lanes down with three receptions rolling through below it. Both things at
once; an earlier commit on this branch moved the playhead to the bottom instead and lost the
roll-through, which is corrected here.

rxPlayhead holds the 6-of-9 proportion at every size, so a five-lane card puts it on lane 3
and a three-lane card on lane 1, never above the middle. rxBelow is the count under it.

Two consequences worth naming:

• maxScroll now reads the browser's own maximum rather than (rows - 1) * lineH. With no
  padding under the last row the list cannot scroll far enough to put that row on the playhead,
  so comparing against the JS lane count made atBottom() permanently false, which latches
  follow off and stops the card following live traffic.
• The fade had to follow. Its fixed divisors reached zero on the outermost lane of each
  side, which was harmless while those lanes were blank padding and is not now that they hold
  receptions: the newest row on a full card sits exactly three below the playhead. Each side now
  fades across the lanes there actually are on it, down to a floor. Measured on an
  eleven-reception card: ten rows visible, none below 0.22.

The chevron

Three stops rather than two: full, three lanes, one lane, then back to full. One control that
swaps state, pointing down while there is further to collapse and up on the last stop.

The cycle is computed per reception count, and that is not a detail. A stop at or above the
card's natural height changes nothing on screen and reads as a dead press. @khagele hit exactly
that by using it: at three receptions the card is three lanes anyway, so the three-lane stop
swallowed a tap and full was indistinguishable from it. collapseLevels(count) now offers only
the stops that make the card smaller, so at three receptions the cycle is full to one lane and
back. Pinned by a test asserting no two stops share a height, for every count from 0 to 60.

Geometry as one source

The numbers have to agree, so they are derived from one another rather than kept in step by
hand. rxLanes, rxPlayhead, rxBelow and rxPadBottom are pure and unit-tested, and the
stylesheet multiplies the lane counts they publish by --ch-rx-line-h.

playhead + below is always lanes - 1, so the two halves always account for the card. Where
the newest reception lands is asserted rather than trusted, worked out the way the browser does
it: content is padTop + rows, the box is lanes, scrollTop clamps to the difference, and
the newest row comes out on lanes - 1 for every size and every row count. That is the whole
reason rxPadBottom is zero.

The curve is pinned as the table above rather than as the thresholds the code uses, so a wrong
implementation disagrees with it instead of restating it.

State

Every on-screen state is one stored value under core-hunter-ticker: open, collapsed,
minimal, closed. A boolean plus a size would let a reload land on "closed and expanded",
which is not a state, and the round trip is asserted for every stop the chevron can reach.
open and closed are what pre-#560 builds wrote, so existing installs keep working and
anything unrecognised reads as a first visit.

Closing travels towards #ticker-btn. The card used to vanish on the spot, leaving nothing
connecting it to the control that now held it.

The parity guard

web/parity.test.js's #322 guard pinned .rx-list's height to the literal 10-lane calc on both
surfaces. Its subject is the pitch, not the number, so it now asserts that neither surface bakes
a pixel value, then pins the map's literals and the app's two sources separately.

It also pins the divergence this creates rather than letting it drift unnoticed. Both surfaces
keep the playhead six lanes down; what differs is the padding under the last row, which the map
still reserves, so a ten-lane map card still ends in three blank lanes. #424 is where the map
follows.

Verified in the browser at 412x915

Driven with synthetic receptions against the table above: 0 gives the header only, 1 and 2 give
1 lane, 3 to 5 give 3, 6 and 9 give 5, 10 and 11 give 10, with zero pixels under the newest
reception at every step and the newest always the last visible row. The playhead measured at the
same time: lane 6 with three receptions below it on a full card, lane 3 of 5, lane 1 of 3, and
the faintest visible row on the floor rather than invisible. The chevron cycle measured per
count: 50 gives 10, 3, 1, 10; 6 gives 5, 3, 1, 5; 3 gives 3, 1, 3; 2 hides the control.

A first attempt animated the height. A running height transition fires scroll events, and
the scroll handler reads atBottom() against a box that is still moving, so follow latched
off and the card stopped following the newest line. The transition is gone.

Not verified here

The closing travel itself. This preview pane runs no CSS transitions at all, confirmed with a
control probe on a throwaway element whose opacity read 1 at 100ms of a 200ms transition, and
document.hidden is true. The end state is verified: the card hides, the button appears, the
state stores, and no class or custom property is left behind. The timeout that guarantees that
is what carried it here.

Tests

• app: 935 passed, build clean
• web: 509 passed
• eslint: clean

The geometry assertions were mutation-checked, and the rewritten parity guard was checked by
baking a pixel height back into the app's rule.

Two things found while building, both out of scope

• soundengine.test.js's "drifts them" case fails intermittently on master as well: 1 of 3
  full runs at 90c3375, same message. It asserts that a random drift produces a new pitch
  within four intervals, so CI can redden on it at random.
• #no-capture-banner in #toast-stack (top 50, z-index 560) covers the ticker card's header
  (top 52, z-index 480) whenever it is up. Both rules predate this branch; the diff does not
  touch either.

🤖 Generated with Claude Code