Various indentation fixes: typos, differentiating new lines, support for do and extension

[maemre]

This PR contains the following fixes to support Scala 3 indentation (numbers 2 and 3 made it way more usable in my experience):

1. Some fixes with propagation of nil values and typos.
2. Disabling emitting the left-boundary token when encountering a left paren: (. This turned out to be too aggressive when the indentation engine needs to look past an open paren to hit a token like class, case and so on.
3. Distinguishing blank lines and the previous non-blank line. This allows proper indentation when hitting return after a class declaration, etc.
4. Adding some support for indenting do and extension keywords properly:

• do is treated just like yield (or then) because there are no more do..while loops in Scala.
• extension needs to be handled specially because extension blocks don't start with a : or = (unlike classes or declarations). Current implementation uses a rough heuristic (observing extension and an occurrence of a newline).

There are still some fixes that need to be made (I can move this bit to hvesalai#160):

• I haven't looked at using the cycling behavior. So far, I have focused on making a good initial guess.
• There is no support for the end keyword. The simplest approach would be to make it reduce indentation by one level, but there are variants like end if, end foo which should scan for the corresponding unclosed block.
• There is an edge case for when re-indenting the statement after the end of a block. Current heuristics assume that this statement would be a continuation of the previous block (I included an example before). For comparison, haskell-mode does not change the indentation in this case.

Here is an example of the last thing I mentioned:

for x <- xs do
  print(x)
  for y <- x.bars do
    val x = print(y)
  print(s"end of $x")  // if we open a new line after this statement, the
                       // indentation heuristics indent both lines to align
                       // with print(y)

After this PR, I can focus on adding support for the end keyword, but solving the last problem would be a bit difficult (it is effectively trying to guess the user's intent). In my opinion, using cycling+a sane default would be the best option there.

[pauloglesby]

Any update on this, folks? It would be awesome to have better scala3 support in emacs 🙏

[maemre]

@Kazark this is ready for review, in case it went unnoticed so far (I couldn't explicitly request a review through the GitHub UI).

After the 4th of July, I'll have some time to work on supporting end and testing out interactions with cycling.

[Kazark]

Yep, somehow I missed this when it first submitted. Apologies! Will take a look now.

[Kazark]

I'm not writing a lot of Scala right at the moment, and too busy to make time to specifically test this. However, everything I see here appears to exhibit an understanding of the existing code, and to be a movement in a good direction. Sorry for the slow review, and keep up the good work!

[Kazark]

Yikes, how did I miss that

[Kazark]

Good thought. This extra piece of information seems useful.

[pauloglesby]

This is great - thanks @maemre & @Kazark 🙌 Looking forward to trying this out on some Scala 3 next week 😄