Numeric comparisons in conditions, and two loop defects they uncovered

[inhuman]

Closes the embedder's task on numeric conditions: >, >=, <, <= where
== and contains already live. Format 2.3.0.

Why

Numbers were in the flow all along — counters, ids, thresholds parsed out of a
request — and the only thing expressible about one was equality with a literal
(ci.id == 0 as a sentinel). Everything else went into the TEXT of a step,
where a deterministic rule ends up applied by a model, or into an asset: a
network call to compare two numbers.

The refusal was not hypothetical. On the first day skills were being written by
a model rather than by hand, it wrote {{pod.restartCount}} > 5, got a parse
error, and wrote the same form again in another step of the same session. Both
attempts were a condition in the body of a for_each.

What is in

• var > 5, var >= req.limit, var < 0.5, var <= days. The right side may
  be a number or the NAME of a variable holding one — a threshold is rarely a
  constant.
• Both ways of not being a number are LOUD. A non-number stops the turn; an
  empty or failed variable is NOT zero and stops it too, with the error naming
  var is not empty as the way to allow emptiness. A condition is the one place
  where a wrong answer leaves no trace: restarts > 5 looks right whatever it
  returns.
• Two integers compare as integers, so a nineteen-digit id does not lose its
  last digits to float64. NaN, Inf and hex floats are not numbers here.
• == is unchanged and still textual: "5" == "5.0" stays false, and
  coercion would quietly change equalities that compare ids and sentinels.
• Braces are still refused ({{x}} > 5), but the error now names the braces and
  prints the condition without them, instead of listing the allowed shapes.
• No arithmetic, no collection filter: for_each plus a condition in its body
  is the shape the case actually arrives in.

Two defects the live shape uncovered

Both were blocking the very example the task is written around, and both are
separate commits.

• A loop over a JSON array of OBJECTS handed its body Go's map formatting
  (map[name:api restartCount:12]). Every field lookup inside the loop —
  {{pod.name}}, a condition on pod.restartCount — resolved to emptiness, and
  the model was shown a syntax belonging to the language the engine happens to
  be written in.
• collect gathered a duplicate wherever an iteration produced nothing. The
  variable was read after every iteration and never cleared, so a loop picking
  two items out of three returned three, and the extra one looks exactly like an
  honest result. parallel had it right all along (it collects produced());
  for_each was the odd one out.

Go API

CondVar → CondVars ([]string). A comparison names a variable on both
sides, and a reader that saw only the left would leave a typo in a threshold
unchecked — which is what such a reader is usually looking for. The linter's W14
now catches it.