This is mainly used for fuzz testing -- we can use gen to
walk a DFA to generate matching input strings up to a certain
length, so then we can compare capture behavior against PCRE
for those particular inputs.

amend: gen tests

This is a big commit, unfortunately difficult to break apart
further due to interface changes, metadata being passed through
whole-FSM transformations, and so on. Sorry about that.

- Delete code related to capture action metadata on edges.
  That approach made FSM transformations (determinisation,
  minimisation, etc.) considerably more expensive, and there
  were some corner cases that I wasn't able to get working
  correctly.

- Switch to a somewhat simpler method, adapted from Russ Cox's
  "Regular Expression Matching: the Virtual Machine Approach".
  Since the capture resolution metadata (an opcode program
  for a virtual machine) is associated with individual end
  states, this combines cleanly when multiple regexes are
  unioned into a single large DFA that matches them all at once.

- Add lots of capture regression tests, mostly from using libfsm's
  `fsm_generate_matches` and a fuzzer to compare behavior against
  PCRE. This brought many, many obscure cases to light.

- Delete capture tests based on the old interface. The new one
  does not work with state machines built manually using libfsm's
  interafces, only via compilation from regex.

- Some performance improvements to trimming and minimisation,
  mostly due to better utilizing bit-parallelism in the edge
  set data structure.

- Switch to using new ADTs in several places.

amend: interface changes

See katef#386 on katef/libfsm.

This is a workaround for a bug in the parser -- once the fuzzer
finds it, it tends to get in the way of finding deeper issues.

Previously it sorted the ALT case subtrees to find and discard unique
ones, but capture results are affected by ALT case ordering, so we
need to preserve ordering while eliminating duplicates.

To build, uncomment `PCRE_CMP=1` in fuzz/Makefile. This depends on
libpcre2-8.

This was pretty much the minimal amount I needed for manual testing.

- `-FC`: No captures, do not build capture metadata even when dialects
  support it.

- Generating input: `build/bin/re -rpcre -G10 '^a*b*$'`

- Capture resolution: `build/bin/re -rpcre -R '^a(b*)c$' abbbbbc`

    -- 0: 0,7
    -- 1: 1,6

- Multiple regexes: `build/bin/re -rpcre -pgC -Y file_with_one_regex_per_line`

Capture resolution is not implemented for -y or multi-regex yet, because
`fsm_exec_with_captures` needs all input buffered ahead of time and
because multi-regex isn't passing along the capture bases and matching
those up based on the result.

There are several tests that have nothing to do with captures,
capture behavior is tested directly with `tests/captures/`.

Also, add a comment about how the iterators yield collated .to states,
so we can avoid the overhead of sorting later.

Update several skipped tests. These should now be run, and
expect libfsm to reject them as unsupported. These will be
fixed by the next commit.

Also, fix the test runner's handling of unsupported inputs.

Expand analysis to detect and reject this special case. It's not
likely to be worth supporting, but was previously not identified
correctly at compile-time.

This has not been fuzzed yet, but with it all tests pass, including
several that were previously set to SKIP.

Add regression test, found via fuzzing.