Simplify compilation of nested patterns

[hubertp]

Pull Request Description

NestedPatternMatch pass desugared complex patterns in a very inefficient way resulting in an exponential generation of the number of case IR (and Truffle) nodes. Every failed nested pattern would copy all the remaining patterns of the original case expression, in a desugared form. While the execution itself of such deeply nested case expression might not have many problems, the time spent in compilation phases certainly was a blocker.

This change desugars deeply nested into individual cases with a fallthrough logic. However the fallthrough logic is implemented directly in Truffle nodes, rather than via IR. That way we can generate much simpler IR for nested patterns.

Consider a simple case of

case x of
    Cons (Cons a b) Nil -> a + b
    Cons a Nil -> a
    _ -> 0

Before the change, the compiler would generate rather large IR even for those two patterns:

case x of
    Cons w y -> case w of
        Cons a b -> case y of
            Nil -> a + b
            _ -> case x of
                Cons a z -> case z of
                    Nil -> a
                    _ -> case x of
                        _ -> 0
                _ -> 0
        _ -> case x of
            Cons a z -> case z of
                Nil -> a
                _ -> case x of
                    _ -> 0
           _ -> 0
    Cons a z -> case z of
        Nil -> a
        _ -> case x of
            _ -> 0
    _ -> 0

Now we generate simple patterns with fallthrough semantics and no catch-all branches:

case x of
    Cons w y -> case w of
        Cons a b -> case y of   ## fallthrough on failed match ## 
            Nil -> a + b                ## fallthrough on failed match ## 
    Cons a z -> case z of
        Nil -> a                          ## fallthrough on failed match ## 
    _ -> 0

Important Notes

If you wonder how much does it improve, then @radeusgd's example in https://www.pivotaltracker.com/story/show/183971366/comments/234688327 used to take at least 8 minutes to compile and run.
Now it takes 5 seconds from cold start.

Also, the example in the benchmark includes compilation time on purpose (that was the main culprit of the slowdown).
For the old implementation I had to kill it after 15 minutes as it still wouldn't finish a single compilation.
Now it runs 2 seconds or less.

Bonus points: This PR will also fix problem reported in https://www.pivotaltracker.com/story/show/184071954 (duplicate errors for nested patterns)

Checklist

Please include the following checklist in your PR:

• The documentation has been updated if necessary.
• All code conforms to the
  Scala,
  Java,
  and
  Rust
  style guides.
• All code has been tested:
  • Unit tests have been written where possible.
  • If GUI codebase was changed: Enso GUI was tested when built using BOTH
    ./run ide build and ./run ide watch.

[hubertp]

I've also noticed that the change shed a few seconds when running test/Tests.

[JaroslavTulach]

The speed up results are great. The code changes look sane (as far as I can see).

[JaroslavTulach]

Should we get more of "compilation benchmarks" then we should put them into their own directory/location. I assume they will fluctuate more than "fast path" ones.

[hubertp]

Yeap, I agree

[JaroslavTulach]

If it is nested, it returns failure in match.

[hubertp]

Correct. This is so that the error does not propagate outside of the case expression.