EXPERIMENT: resolve the crossing at execution, not at emission

HYPOTHESIS (Will's): a compiler whose one compiled mechanism is extending the
LANGUAGE — not the compiler — can compose without recompilation.

ISHIKAWA — why does a construct require a recompile today?
  method       codegen inlines the target call into the body
  machine      the binary has no table to consult
  material     the declaration lives in source, read at compile time
  measurement  nothing observes what applied at runtime
  root cause   the crossing is resolved at EMISSION, not at EXECUTION

CHANGE: codegen emits one unconditional indirection per fn. Which constructs
apply is read from a table that can be written AFTER the binary exists;
targets resolve through dlsym against the running image.

PREDICTIONS AND RESULTS
  P1 a construct declared after the build applies       TRUE
  P2 an unlinked target is skipped, not fatal           TRUE
  P3 emitting on every fn is measurably slower          FALSE — 0.37s -> 0.36s
                                                        with 267 indirections and
                                                        no bindings. Free unused.
  P4 the compiler still self-hosts                      TRUE (see note)

DEMONSTRATED: an El program with NO decorator in its source, already compiled
and linked, picked up a construct declared afterwards:

    $ /tmp/seamrun                       -> 7
    $ echo 'work audited entry audit_entry' > constructs.txt
    $ EL_CONSTRUCTS=constructs.txt /tmp/seamrun
      AUDIT: work applied by audited
      7

P4 note: my first fixpoint test was wrong, not the code. I compared gen1 to
gen2, which must differ whenever codegen's output changes. gen2 == gen3, 267
seam sites, stable.

MEASURED COST, and the root cause was not where I looked
  0 bindings                    0.36s vs 0.37s baseline   free
  2 bindings, dlsym per call    2.45s                     6.6x
  2 bindings, resolved once     0.69s                     3.5x recovered
The table scan was never the cost. dlsym walks the dynamic symbol table on
every call. Resolve once and cache — which is the smallest form of what
salience does for memory: what is hot stays resolved. The 0.69s residual is
audit_entry's own printf on two of the compiler's hottest functions, not seam
overhead.

CONSEQUENCE: the five compile-time declaration kinds on iteration-1 are a
compile-time specialisation of something that resolves at runtime. They are not
wrong, but they are not the mechanism — the mechanism is one indirection, and a
kind is data.

lang/runtime/el_runtime.h

@@ -887,7 +887,8 @@ el_val_t  engram_age_field(el_val_t delta_ms);
 el_val_t  engram_age_field_catchup(void);
 el_val_t  engram_chrono_persist_tick(void);
 el_val_t  engram_chrono_tick(void);
-el_val_t  engram_boundary_beat(el_val_t op_name, el_val_t construct);  /* API-reshape decorator-seam auto-emit; construct = the decorator that caused the beat */
+el_val_t  engram_boundary_beat(el_val_t op_name, el_val_t construct);
+el_val_t  el_seam_run(el_val_t fn_name, el_val_t phase, el_val_t result);  /* runtime construct seam */  /* API-reshape decorator-seam auto-emit; construct = the decorator that caused the beat */
 el_val_t  engram_self_anchor_capture(void);
 el_val_t  engram_self_drift_json(void);
 el_val_t  engram_neighbors_json(el_val_t node_id, el_val_t max_depth, el_val_t direction);