feat(codegen): higher-order calls through computed and field callees

[MelbourneDeveloper]

TLDR

Calls and iterator callbacks whose callee is an arbitrary expression — a chained application add3(1)(2)(3), a function held in a record field cfg.processor, or any computed call result — now compile and dispatch through the closure cell instead of failing with unsupported construct.

Details

For an FP language this closes a core gap: only a plain-identifier callee (or the special maker(args)(args) shape) lowered before; everything else bailed (indirect / higher-order call, or iterator callback must be a function name or lambda). The dispatch machinery (closure::cell_call) already existed — the missing piece was recovering the callee's signature.

• crates/osprey-codegen/src/builder.rs — new callee_fn_type(expr) recovers the function Type an expression evaluates to in callee/callback position: a named function or function-typed local, a chained call (peeling one arrow per application, so add3(1)(2)(3) resolves), or a function-valued record field (resolving the owner from the bound value's type tag, else a unique field-name match).
• crates/osprey-codegen/src/expr.rs — gen_call's non-identifier callee now recovers a FnSig via callee_fn_type and dispatches through call_fn_value → cell_call; it still fails loudly when the callee is not a function value.
• crates/osprey-codegen/src/iter.rs — callback_of gains a Callback::Value variant: a computed/field callback is evaluated once to a closure handle and called per element through its cell, so map/filter/fold/forEach accept makeAdder(10) and cfg.processor as callbacks.

Out of scope (separately tracked): the UFCS method-call spelling obj.field(args), which the parser desugars to field(obj, args); function_composition_test already documents this. The capability is reachable today via let p = obj.field then p(x), or as an iterator callback.

Closes plan 0001; removes it from docs/plans/.

How Do The Automated Tests Prove It Works?

• New codegen unit test higher_order_calls_through_computed_and_field_callees compiles a program with all three forms (chained 3-deep call, makeAdder(10) map callback, cfg.keep filter callback) and asserts the IR contains a closure cell-call (to { i8* }*) — i.e. each higher-order callee loads a function pointer from a cell rather than erroring.
• Extended golden compiler/examples/tested/basics/function_composition_test.osp adds chain3: ${tri3(1)(2)(3)} computed: ${...} fieldcb: ${...} and asserts chain3: 6 computed: 36 fieldcb: 23 byte-for-byte (range(1,4) mapped through makeAdder(10) folds to 36; range(8,13) filtered by the field predicate n > 10 folds to 23).
• Differential harness PASS=47 FAIL=0 NOEXP=0, FC_OK — the change is purely additive (it only fires where codegen previously bailed), so no existing example regresses.
• Coverage holds: osprey-codegen 95.6% ≥ 95%. Full-workspace cargo fmt --check, cargo clippy --workspace --all-targets -D warnings, and cargo test --workspace are clean.