Get rid of most generated variables

[yannham]

Fixes #1647.

Context

This PR adds a new node to the AST, Closure, which contains a "pointer" (more abstractly, a cache index, in practice a thunk) to an allocated closure. This removes the need of closurizing terms in the environment everywhere.

The first motivation was performance, as we used to allocate specific variables and put them in the environment to store those closures, with renaming issues, environment propagations, and paying the price of environment insertion and lookup. Now, we basically just use direct pointers.

The price to pay is that Closure now leaks in the AST, even at stages where it doesn't make sense. Ideally, having separate ASTs for parsing and for evaluation would make this cleaner, and is the eventual plan - but for now, it's an ok price to pay to fix some big performance issues. Also, this change makes a lot of code much simpler, because we don't have to propagate and think about nested environments for closurization anymore. There's a lot less threading to do.

Content

• Adds a Closure node to the AST
• Get rid of the share normal form transformation. This was the one creating a lot of let-binding with generated variables. Instead, we rely on the closurized attributes of arrays and records to know if something is a "fresh" array or record - in which case we allocate the closures for each element at first evaluation - or if it's already "transformed". In some sense, this PR factors the share normal form transformation directly into evaluation, removing the need of creating intermediate let-bindings and allocating the corresponding slot in the environment.
• Moves the trait Closurizable into its specific module, and rename it Closurize. We still use closurize because it's handy, but the signature is simpler.
• Updates various part of the codebase in consequence

Effects

On the codebase provided for #1622, this change doesn't gain an order of magnitude but still seems to provide a boost of around 20-30% (it's hard to say more without a proper statistical method, because there is a lot of variance across runs - an effect of Sip hashing?). It's noticeable without being game changing.

However, on other examples, the gain is drastic. On an example reported in the online chat by another user, this:

let things = std.array.range 0 3000
    |> std.array.map (fun number => {
        a = 0,
        b = 1,
        c = 2,
    })
in

things
    |> std.array.flat_map std.record.values
    |> std.array.at 0

Was basically taking forever (didn't finish before interrupted, and worked for at least a solid minute). After this change, it takes between 2 and 3 seconds (it's still a bit high, but nowhere near the previous numbers).

Follow-up

One medium-term follow-up would be to split the AST, and have 1. a concrete AST with no mention of closures 2. A runtime AST with versions of Array and (Rec)Record which enforce their elements are stored inside closures.

[jneem]

I'm definitely lacking some context here, but I did have a look at least...