Changing the leaf and endleaf callbacks to accept and reject in #485
broke lx, but it went unnoticed for a while. This fixes it.

libfsm's normal execution mode evaluates a DFA, character by character,
terminating either when the next character isn't a valid edge or the end
of input is reached (in which case it checks end state metadata). lx's
execution mode is a little different, because it's tokenizing -- instead
of reading to the end of input, it should consume as much consecutive
input that matches a particular token, then push back the last character
read (so it can resume with it as context for the next token), yield the
token type, and suspend.

lx used to work by breaking abstraction and calling directly into
`fsm_print_cfrag` (overriding the leaf behavior to yield token types,
and adding an extra 'NONE' state to the generated state machine code),
but when the callback interfaces shifted its internals no longer fit
what lx expected. Now the reject hook is passed the same state
metadata as the accept state, and the reject hook in lx checks whether
the end id is associated with a particular AST mapping and token type.

This is only implemented for the "c" output format, but similar changes
could possibly make others usable without a lot more work. In
particular, kate mentioned it'd be good to be able to use "vmc" output
instead of "c" moving forward.

Most of the code changes happen inside of lx's code generation, but
there are a few elsewhere:

- The reject hook now has a state_metadata pointer, so update the
callers for all the output formats.

- libfsm's 'c' output now includes a macro `FSM_ADVANCE_HOOK(C)`,
which is called with the next character read in the FSM_IO_STR and
FSM_IO_PAIR io modes immediately after advancing. This is used to inform
lx's internal bookkeeping about token positions and buffering token
names. FSM_IO_GETC doesn't need it, because its getc callback manages
the character stream. The macro defaults to a no-op when undefined.

- libfsm's 'c' output also includes a flag, `has_consumed_input`, so the
code expanded in place from the reject/accept hooks can determine when
the state machine input handler loop has consumed any input. This was
previously encoded by the extra NONE state.

lx's code generation using this flag is a bit cluttered, because the
reject hook doesn't know whether it's expanding for the end states, but
it's probably not worth changing the reject hook type signature to add
another flag. This results in checks for has_consumed_input in code
paths where trivial static analysis would show it to be dead code, and
some extra unreachable code at the end of the function.

Instead of having the EOF token occupy the same byte, line, and column
position as the last token, it should immediately follow.

The new lx codegen behaves this way, and katef and I decided that it
made sense to keep it like that, as long as it's consistent.

Add `${LX}` as a dependency for the targets using it.

Remove the `getcio=${io}` and `io=${io}` arguments to cat. Those may be
a merge error? They just produce a warning.

Add a couple test cases (in8-10.txt) with an unexpected end of input,
either in the middle of a pattern, or after matching the first pattern
in a .. pair, but without matching the second.

Supporting this changes the expected result for in6.txt: Previously it
resulted in TOK_EOF, now it leads to TOK_UNKNOWN and produces a
"lexically uncategorised" error message for the unexpected end of input.
This change is necessary for fixing #386 / #508, and more generally
to detect things like unterminated string literals.

These may or may not be called, depending on the input.

In some cases this was hardcoding "lx_" in the generated code, which
could lead to build failures if 'lx -e' was used to override the default
prefix.

This avoids cluttering libfsm's print output with `has_consumed_input`,
which is specific to lx.

Tested with every combination of (dyn+fgetc, fixed+fgetc, pair, str),
with and without '-x buf', '-x pos', or both.