Changes to how match statements interact with enums

[Akuli]

Two things.

Compiler must know what enum values are matched

This is no longer valid:

enum Thingy:
    Foo
    Bar
    Baz

def get_bar() -> Thingy:
    return Thingy.Bar

def do_stuff(t: Thingy) -> None:
    match t:
        case get_bar():  # error on this line
            ...

When matching over enums, cases must be simple EnumName.MemberName, nothing more complicated is allowed.

New UB

After this PR, the following function will invoke UB if you do thingy_to_string(7 as Thingy):

enum Thingy:
    Foo
    Bar
    Baz

def thingy_to_string(t: Thingy) -> byte*:
    match t:
        case Thingy.Foo:
            return "It's a foo"
        case Thingy.Bar:
            return "Barbar"
        case Thingy.Baz:
            return "Bazzz"
    # We never get here, because we return in all cases

Currently the match statement does nothing, which means that the compiler should complain about how the function might not return a value. It doesn't because undefined value checks are currently missing. After this PR, the match statement invokes UB.

UB happens only in a very specific scenario:

• Matching over an enum
• All enum members are handled one by one (otherwise, there is a compiler error)
• No case _
• Value passed to match statement is not one of the enum members

I will document this (and other match statement things) in next PR.