feat: add a whole-program optimizing compiler section to the front page

[magnus-madsen]

Adds a section to the front page showing what the compiler does to the code it generates — built around a worked example and the bytecode actually emitted for it, rather than a list of claims.

The figure

def sumWith(f: a -> Int32, arr: Array[a, r]): Int32 \ r =
    Array.foldLeft((acc, x) -> acc + f(x), 0, arr)

def main(): Unit \ IO =
    region rc {
        let arr = Array#{1, 2, 3, 4, 5} @ rc;
        println(sumWith(x -> x * x, arr))
    }

A polymorphic, higher-order fold over a mutable array in a region compiles to a 34-byte counted loop taking a bare int[] and three raw ints, with the lambda reduced to a single imul and the recursion to goto 0.

Every claim beside the listing was verified against a real build with flix 0.75.2:

• No closure allocation — no Clo$main$* class is emitted at all, so neither sumWith nor the lambda survives as a closure.
• No recursion — Array.foldLeft is recursive; the emitted code ends in goto 0.
• No boxing — the loop signature is (int[], int, int, int); only the final result is boxed.
• No dispatch — the loop body's entire opcode inventory is loads, stores, arithmetic and branches. No invoke, new, or newarray.

The listing elides only the trailing boxing of the result. The loop body has no constant-pool references at all, so it is otherwise verbatim javap output plus comments, reproducible with flix build followed by javap -c -p.

Placement and framing

It sits after "Compiler Performance: The Raw Numbers", so the compiler region reads architecture → compiler speed → generated-code quality. That section already claims the compiler is fast "despite supporting costly features, including monomorphization and whole-program optimization" without ever saying what those are; the new section's title and lead now name them.

How the example was chosen

Three variants were built and disassembled before settling on the region-based one:

	classes	jar	loop signature	allocation in loop
List	172	83K	(int, Tagged$)	none in the fold
Vector	169	80K	(int, int, int)	newarray every iteration
region Array	165	78K	(int[], int, int, int)	none

The region version wins on every axis, and earns a claim the others can't: the region has no runtime representation in the loop — main allocates a Region$, but the loop receives a plain array.