Implement branch coverage - #9751

Coverage's branches mode now works and produces the same results as CRuby
(its default, prism-based compiler):

  { file => { branches: {
      [:if, 0, 2, 2, 6, 5] => { [:then, 1, 3, 4, 3, 5] => 2, [:else, 2, 5, 4, 5, 5] => 1 },
      ... } } }

Every branching construct (if, unless, elsif chains, ternaries, modifiers,
case/when, case/in, while, until, their modifier forms including
begin/end while, and safe navigation calls and assignments) is reported with
the same keys, locations, numbering and counts as CRuby, including its
corner cases: empty arms and missing else clauses, a clause's own span when
its body is empty, elsif clauses reaching the shared end, loop bodies that
never run, nil paths of every call in a &. chain, parenthesized arms, and
conditionals on literal predicates, which CRuby folds away together with
everything inside the arm that cannot run.

Design, following the same shape as method coverage:

- BranchCoverage / BranchTarget hold one branching construct and the places
  it branches to, each target owning a lock-free atomic counter; FileCoverage
  keeps them in declaration order and identifies them by type and span, so
  building the same source again (a reloaded file, a block turned into a
  method) finds the existing counters rather than declaring new ones. A
  result is built from a copy taken under the CoverageData lock, which
  reads and clears each count in one atomic step, so a branch reached
  while Coverage.result(clear: true) runs is reported once, not dropped.
- The IR builder declares constructs while it builds their IR, in the order
  CRuby's compiler meets them (an if after its predicate, a loop or case
  before, a safe navigation after its receiver), and emits a
  CoverBranchInstr at the start of each arm. The instruction holds the
  counter directly; JIT-compiled code binds to it through an invokedynamic
  site keyed by file and target index. Methods are built eagerly while
  branches are measured so a file's result lists every branch, and lazy
  &. chains no longer share a nil exit so each call's nil path counts.
- The parser records a source span on every AST node: the generated parser
  now gives each node the location of the production that produced it
  (widened by enclosing productions that hand the node along, until an
  explicit span locks it; calls keep the span they were created with so an
  attached block is not part of them), and empty productions get bison's
  zero-width location instead of a stale one. The grammar records the extra
  positions branch keys need (where a predicate ends, where an else keyword
  starts, a when/in clause through its then, a modifier's statement as
  written, the parentheses around an arm) and whether a conditional is one
  CRuby folds.

Coverage.supported?(:branches) is now true and the "branch coverage is not
supported" warning is gone. Un-excludes the MRI branch coverage tests
(including test_coverage_supported, test_coverage_ensure_if_return and
test_tag_break_with_branch_coverage) and adds JRuby tests for keys and
counts, result shape, suspend/resume/clear, exact counts under parallel
calls, reloaded files and define_method blocks, and every execution mode.

See jruby#5147

define_method(:new_name, some_method) adds a copy of some_method that
keeps its name. MRI keys the coverage entry by the method's original_id,
so for

  class A; def foo; end; end
  class B < A; define_method(:bar, A.instance_method(:foo)); end

it reports [B, :foo, ...], not [B, :bar, ...], on every version from
3.3 to master (rb_coverage_method_data_of in thread.c). This reverts
the keying by the added name from caf18c6, which assumed the
opposite.