Implement ADT contracts

[yannham]

Depends on #1820

Several previous PRs (starting with #1770) introduced various stage of structural ADTs. A missing follow-up was that enum contracts weren't yet updated to handle the new enum variants. This PR implements correctly contracts for those new extended enums.

Content

• refactoring: various type components (enum rows, record rows, etc.) had a similar method subcontract. As a first step, this PR refactors that into a proper trait (it's a bit orthogonal to the ADT contracts, and is more an incidental cleaning). Although the diff is a bit large, most of subcontract() methods have been left untouched and are just moving around - the only interesting changes are of course in the EnumRows::subcontract method.

• refactoring: moving code around in internals.ncl to group internals by theme (record, enums, etc.). Same here: moderate diff, but actually very little new content, beside comments

• Extend the translation of an enum type to a contract. As before, the translation relies on a match expression: [| 'Foo, 'Bar Contract; r |] is just translated as (the example is just written in a slightly higher level code than in reality)

  fun label value => value |> match {
    'Foo => value,
    'Bar arg => std.contract.apply Contract label arg,
    _ => $enum_tail value
  }
  |> $enum
  

  Where $enum is just a wrapper that checks that the value is an enum first.

Parametricity

As explained inside internals.ncl, the enum contracts don't enforce parametricity. The first reason is that it's not trivial to do, as we would need to let match expressions see through a sealed value but only if it ends up matching the catch-all case. Although annoying, this is doable.

The main reason is that the contract wasn't enforcing parametricity correctly before, and thus such a change would be backward incompatible. As an illustration that this isn't just a theoretical case (user code relying on enum contracts not enforcing parametricity): even in the standard library we are abusing enums, for example in std.string.from_enum: forall r. [|; r|] -> String. While forall r. [| ; r |] -> ... can look like a reasonable type for a function that takes any enum as a parameter, parametrictiy would enforce that such a function doesn't actually look into its argument. Thus, a parametric contract would make from_enum fail on valid input, which would require to change its contract, which means changing the stdlib interface.

[dpulls]

🎉 All dependencies have been resolved !