bench: arm the Phase 4 gate -- proven to pass clean AND fire on a quadratic

Adds tests/native/test_lexer_scaling.el, the regression gate for el #132.

Both directions are proven on LIVE workloads, not synthetic series:
  healthy per-character scan  1821 3251 6007 10422 us -> O(n)   PASS
  rescan-from-zero (the #132 shape)  922 3667 13524 44792 -> O(n^2) FAIL

A gate only proven to pass is decoration. The quadratic specimen exists so
the gate is proven to FIRE.

Also fixes elb_spread_ok to judge the ASYMPTOTIC TAIL (last three ratios)
rather than the whole sweep. Measured on a genuinely linear scan the ratios
ran 3.37 2.92 1.76 1.65 -- the head looks quadratic because it is cold
cache, the tail is the truth. Whole-sweep spread rejected correct data. A
complexity bound is an asymptotic claim and must be judged asymptotically.

That fix came from the classifier refusing to rubber-stamp my own bad
measurement: it reported INDETERMINATE on an unwarmed sweep rather than
passing it. Warmup is now taken and discarded at every sweep point.

Reverts the == workarounds in test_elbench.el now that el #137 has landed;
the natural form generates no str_eq and all 13 fitter tests stay green.
The  workaround remains -- the Plus arm is still open.

lang/runtime/elbench.el

@@ -147,12 +147,24 @@ fn elb_implausibly_flat(vals: [Int]) -> Bool {
 // This is the ratio-method analogue of a normalised-RMS threshold. If the
 // doublings disagree wildly the data is noise, a cache cliff, or a phase
 // change, and the honest report is INDETERMINATE rather than a classification.
+// Applies to the ASYMPTOTIC TAIL only — the last three ratios.
+//
+// The small-n end of any sweep is dominated by fixed overhead, cold caches and
+// branch predictors that have not warmed. Measured on a genuinely linear
+// character scan, the ratios ran 3.37, 2.92, 1.76, 1.65: the head looks
+// quadratic, the tail is the truth. Checking spread across the whole sweep
+// therefore rejects correct data. A complexity bound is an asymptotic claim, so
+// it is judged on the asymptotic region — the same reason a benchmark harness
+// discards warmup rather than averaging it in.
 fn elb_spread_ok(ratios: [Int]) -> Bool {
-    let n: Int = native_list_len(ratios)
-    if n < 2 { return true }
+    let total: Int = native_list_len(ratios)
+    if total < 2 { return true }
+    let start: Int = total - 3
+    if start < 0 { let start = 0 }
+    let n: Int = total
     let lo: Int = 999999
     let hi: Int = 0
-    let i: Int = 0
+    let i: Int = start
     while i < n {
         let r: Int = native_list_get(ratios, i)
         if r >= 0 {