Fix line coverage of statements inside string interpolation and heredocs - #9682

A statement's line event waits for the statement's first instruction. When
building its value reached a statement of its own first, such as one of
several statements in an interpolation, that statement's event replaced
the outer one, so coverage never counted the outer statement's line:
x = "#{\n  a = 1\n  a\n}" read [0, 1, 1, nil] where MRI reads [1, 1, 1, nil].
When coverage is on, emit the outer statement's pending event before the
inner one replaces it.

A begin statement now asks for its body's line, the line the parser marks
for it, so emitting its event does not count the begin keyword's line.

A statement's line event waits for its first instruction and then took the
line of whatever call had been built since, so o.b =\n  [].size counted on
the [].size line, a line the parser never marked: the results read
[1, 0, 0] instead of counting the statement. Emit the event on the line it
was requested for, then restore the call's line for backtraces, so
backtraces do not change.

As in MRI, a statement is a line event unless the last line event was on
the same line; calls built in between no longer hide one (the 1 in
if\n  [].size then 1 end was not counted). A pending coverage event is no
longer replaced by a call's backtrace line either.

An array literal took the line of its first element, a hash literal the
line of its first key, a string the line its contents end on (or, for
"" "..." concatenated, the line of the second string), a regexp without
interpolation the line its contents end on, and a dynamic symbol, regexp,
or backtick string the start of its contents, which for an empty
production is not a real position (nor is it for the elements of %W, %I
and %i lists, or a "string": label). MRI reports each on the line of its
opening token; use that line for all of them.

MRI counts a statement on the line of its first instruction, which is a
later line whenever evaluating the statement starts with a part on one:
x =\n  [].size counts on line 2, and so does x = <<~EOS whose body starts
with an interpolation (x = <<~EOS\n  #{1.to_s}\nEOS reads [nil, 1, nil]).
JRuby marked and counted the line the statement starts on.

LineEvents finds the node whose instructions come first, following
assignment values, call receivers, conditions, the first element of an
array or key of a hash that MRI does not build as one literal, the first
interpolation of a string that does not start with a literal part, and
so on. The parser marks its line, Coverage.line_stub reports it, and the
IR builder counts the statement on it. As in MRI, a statement inside
another that starts with the same instruction shares its line event,
and a statement is no line event when the last one started on its line.

Along the way:

- The newline flags the lexer puts on heredoc lines for dedenting are
  cleared after dedenting, so the IR builder no longer takes those lines
  for statements.
- An ensure body is built before the body it protects; its line events
  no longer count as the last ones when building the protected body.
- A lone conditional in an interpolation stays a line event, as MRI
  counts its branches.

Against MRI 3.4, Coverage.line_stub now matches for 749 of the 840
files in lib/ruby/stdlib (510 before), with no line that matched before
differing now.

After reading a heredoc the lexer goes back to the line the heredoc
started on, and only skips past the heredoc when it reads the next line.
When the heredoc ends the file there is no next line, so the coverage
array stopped short: x = <<~EOS\n  #{1.to_s}\nEOS read [nil, 1] instead of
[nil, 1, nil]. Size it by the last line read instead.

MRI parses the arms of a ternary as statements, so each is a line event
of its own: in x = y.size ?\n  1 : 2, the arm on the second line is counted
by line coverage and reported to line tracing. JRuby parsed them as plain
expressions, so that line read nil.