Fixes #553

This roughly corresponds to our idea that we talked about:

1. we keep the stack of closing delimiters in the ParserContext
2. push the expected closing delimiter (context-dependent) after we enter the delimited group
3. Attempt to recover from the delimited body parse by using greedy scan, in case it's incomplete or there's no closing delimiter immediately following
   a. We keep a local stack, push and pop if we see the corresponding open/close delimiters
   b. Only recover when the local stack is empty and the expected delimiter is encountered

This helps us recover from some of the simpler cases; it'd be great to follow up with better recovery in the terminated/delimited scenario and I need to put more thought how we can best recover from cases like { ( } )

EDIT:
After noticing that

function func() {
  uint a = 1 + 2 * 3;
}

skips the 1 + 2 * 3 in the final CST, I had to go back and fix how eager we are when attempting the recovery.

The main fix is in e647ba8 and the rest is mainly fixing the resulting regressions.
When backtracking/in a choice, we now will pick parses that skip less input. Without recovery, we had the following:

• match (a full match)
• incomplete match (partial prefix match)
• no match

and so, the choice is obvious - match > incomplete match (longer prefix is better) > no match.

However, this PR introduces a new kind of a recovered match. For the purposes of the old system, we treat it as a match, but we disambiguate by recursively checking if the node contains a TokenKind::SKIPPED (in which case, we attempted a recovery). This is necessary, since now the recovered matches can have skipped tokens at any point inside and we need to pick the best matching one, so that we always still pick the "correct" parse over a recovered one.

This is suboptimal and we may optimize that in a follow-up by introducing a RecoveredMatch variant and propagate it upwards and/or also keep the non-skipped text length of the descendent tokens to avoid recalculating that with each choice consideration. I hope that this can be simplified once we cut down on the backtracking at some point.

I checked with the smoke test suite and it looks that we don't seem to have misparses anymore (although it would be great to get a second set of eyes on the results) and that the errors greatly stem from other issues (e.g. from/error contextual keywords not being handled, incorrect pragma solidity annotations in source).