No significant behavioural change.

Same Game doesn't want to show the keyboard cursor when the game is in a
state where no move is possible.  Previously, it did this by having
game_changed_state() hide the cursor on entry to such a state.  That
meant that reaching a dead end and undoing out of it hid the cursor,
which was confusing.

Now the cursor is hidden in game_redraw() if the game is in a dead-end
state without changing the displaysel flag in the game_ui.  That way, if
you undo out of a dead end, the cursor becomes visible again if it was
visible before.

This does mean that you can move the cursor in a dead-end state without
being able to see where it's going.  I think that's tolerable, but maybe
the cursor keys should be disabled in that state as well.

Pressing "undo", for instance, should leave the keyboard cursor
visible if it's visible already.  Only mouse clicks should hide it.

TILE_GAP represents the gap between the coloured parts of adjacent
different-coloured tiles.  Rather than a fixed 2 pixels, it's now 1/16
of the tilesize (rounded to nearest).

This looks the same at the default tilesize of 32, but behaves better
with larger or smaller tilesizes.  At tilesizes below 8, the gap
disappears altogether, but that seems appropriate: at 7 pixels there's
not much space for the inner and outer squares and the cursor, and those
are all more important than the gap..

I've rewritten tile_redraw to reduce the number of calls to
draw_rect().  Before, it would generally make five calls to
draw_rect() when drawing a tile.  Now it makes at most three, and
usually two.  That's one draw_rect() for each colour that appears in
the tile, which is as good as it can get.  This reduces the time to
draw a large puzzle by about 35% on Firefox 102.

This is of significance to me because CanvasRenderingContext2D on my
test KaiOS device seems to have a limit on the number of fill() and
fillRect() calls that it will tolerate in a short time.  This means
that if you issue more than 1024 fillRect() calls in rapid succession,
the later ones are simply ignored.

Same Game's largest preset called draw_rect() so much that it hit this
limit.  That meant that the right-hand side of the grid didn't get
properly drawn when starting a new game.  Now that it is less
profligate with draw_rect() it fits comfortably within the limit and I
get to see the entire grid.

This should ensure that the cursor is visible on the background.

The keyboard cursor in Same Game is white.  The default yellow,
cyan, and light green were light enough to make the cursor hard to
see.  I've darkened them all (without changing their hues) so that the
cursor is acceptably visible.  This doesn't leave an ideal set of
colours, but they are at least still adequately distinct from one
another.

A test-build with a modern clang points out a number of 'set but not
used' variables, which clang seems to have got better at recently.

In cases where there's conditioned-out or commented-out code using the
variable, I've left it in and added a warning-suppressing cast to
void. Otherwise I've just deleted the variables.

All the other constants named UI_* are special key names that can be
passed to midend_process_key(), but UI_UPDATE is a special return value
from the back-end interpret_move() function instead.  This renaming
makes the distinction clear and provides a naming convention for future
special return values from interpret_move().