Scroll a number in place instead of hunting for it on a keypad

[sandman21vs]

Word numbers are typed on a twelve-key keypad. The two buttons walk a cursor
across it, so both gestures go on navigation and the reader has to find each
digit, then find Accept. A number is not a position in a grid.

This scrolls the value in place instead: up and down are the digit.

            Word 3/12
              ▲
          ┌───┬───┬───┬───┐
          │ 2 │ 4 │ 0 │   │
          └───┴───┴───┴───┘
              ▼
       BOTH continue   Up/Down back

Boxes before the active one are set, the active one scrolls, the ones after are
still to come. Adapted from Blockstream Jade's PIN and index entry
(main/ui/digit_entry.c), which shows the same three states.

Dice rolls scroll in one wider box for the same reason, keeping their quality
bar underneath. A card keeps the text screen: A Clubs does not fit a box, and
its running transcript wants the room.

Where a number ends

The ring for the active box carries the digits that still lead somewhere, then
OK once what is typed already names a word, then backspace.

That OK is the part that matters, and the first version of this branch got it
wrong by leaving it out. With a fixed four-box field, 240 is a dead end — no
fourth digit takes 240x into 1..2048 — so the reader who typed it found a box
holding nothing but backspace, and the only way to mean 240 was to have known
to type 0240 from the start. Ending a number early is not a convenience here;
without it, three-digit numbers are not reachable at all except through a
leading zero the reader has no reason to expect.

Two consequences worth stating, because neither is arbitrary:

• OK is absent on an empty field, since nothing is named yet.
• OK is present on a prefix like 20, because 20 is both a word number
  and a step towards 200x. Both readings are live, so the reader is the one who
  says which was meant rather than the field guessing.

A fourth digit still confirms itself — there is no fifth box to put an OK in.
Going back from the confirmation reopens that fourth digit when it was the
fourth digit that confirmed, and returns to the field untouched when the reader
ended with OK.

Digit pruning is unchanged: seedtool_next_digits already offered only digits
that leave a word number reachable, which is what keeps 2049 untypeable while
2048 stays reachable. The ring is built from its answer.

What moved

• seedtool_render_digits — the row of boxes, and seedtool_render_value_box
  for a value scrolled whole rather than digit by digit.
• seedtool_render_dice_screen's bar moved into draw_progress_bar, so the
  dice screen and the scrolled field draw the same bar instead of each carrying
  a copy.
• enter_word_number rewritten around the ring; enter_value routes a plain
  number to the box and leaves formatted values (cards) on the text screen.

The account-index keypad is deliberately untouched. Its prefixes are all
already valid in-range values, so it has nothing to prune and no early-ending
question to answer — the keypad costs it nothing. Converting it would be
consistency for its own sake, and is easy to add later if that reads better.

Testing

./tools/run-simulator.sh --self-test     # passes
python3 -m unittest discover -s tests    # 47 passed

Neither suite reaches rendering or navigation, so this change is almost
entirely outside what they cover. It was driven by hand in the simulator, and
the 240 dead end above was found that way rather than by any test — after the
first version had already been pushed. Worth knowing when reviewing: the box
geometry (34x32 boxes, 11x7 arrows, OK centred in a box) is arithmetic that
has only been checked by eye on the simulator, not measured.

The firmware build and its reproducibility check have not been run here — only
the host build and the Python suite.

Notes

Branched from main. Merges cleanly with #3 and #6.

Conflicts with #4, and not trivially: that PR threads a checksum filter
through enter_word_number, and this rewrites that function. If #4 lands
first I will reapply the filter on top of the ring — it fits well there, since
the ring is built per box and would simply drop digits that cannot lead to an
allowed word, making the impossible last words unreachable on the number pad
the same way they are on the letters.