Allow casing over multiple expressions

Casing over multiple expressions is something that comes up in several cases. Currently, you can do this by wrapping things up in a record and casing over that.

-- a silly example, I know
case { left = 1, right = 3 } of
  { left = 1 } -> "Left is one!"
  { right = 1 } -> "Right is three!"
  _ -> "Left and right are not ones"

However, this isn't ideal as it requires allocating a data structure in order to perform the comparison, which is bad for hot loops. Also, for simple cases, it adds a bit of boilerplate (the names of the record fields) which, for a local single-used expression, doesn't add a ton of value.

To solve the efficiency problem, without loosing too much readability, one could allow for multiple expressions in a case of expression:

-- a silly example, I know
case 1, 3 of
  1, _ -> "Left is one!"
  _, 1 -> "Right is three!"
  _ -> "Left and right are not ones"

Alternatives

Previously Gren had tuples, which was quite often used for cases like these. However, tuples have the same performance overhead as records (they're compiled to the same thing) and tuples as a datastructre makes code more brittle as everything depends on the order of arguments. Positional semantics aren't that big of a deal in a single expression, but they're a problem when in a data structure.

No source files, tests, or compiler entry points are named in the issue. Start by locating the parser and compiler paths for case expressions, then assess the proposed multi-expression syntax and its performance implications. Done means the syntax is designed, implemented, and covered by relevant compiler tests.