Changing the leaf and endleaf callbacks to accept and reject in #485
broke lx. This commit passes through the necessary information to
restore the old behavior. It works in the happy path, but needs further
testing.

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 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),
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.

Further things to check:

- There's a special case for the end of input, because it can't unget
  the next character. Ensure a token at EOI is tagged correctly.

- It currently doesn't check if the state is an end state, just whether
  it has at least one endid. This shouldn't matter, but it should check.

- It also doesn't handle multiple end IDs. lx seems to report errors for
  inputs that can match multiple tokens, so this may be unreachable.

- It's only implemented for the "c" output format, but would probably
  be usabled by others without a lot more work. In particular, kate
  mentioned it'd be good to be able to use vmc output for lx.

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.