Paths into a value, and a handbook the tool can reach

[inhuman]

Two embedder tasks, both measured on the same three days of a model writing
skills. Format 2.4.0.

1. A reference may be a PATH

instruction: "{{pod.metadata.name}} restarted {{pod.status.containerStatuses[0].restartCount}} times"
cond: "pod.status.containerStatuses[0].restartCount > 0"

Substitution used to stop at one field, and the comment beside it said the
observed cases were flat. They were, and then they were not: a tool's answer is
as deep as the tool made it. Of sixteen live generations of a step description,
six were refused by the format and five of the six were this one case — and
the same measurement with the list of allowed fields in the prompt (4.3 KB of
it) held the same share of refusals. The format was short of a form, not the
author short of the docs.

An index is [0], not .0: that is what authors write, and it keeps a path
unambiguous — .0 would be the field named "0", a legal JSON key, and an index
at the same time. Still absent on purpose: [*], filters, arithmetic. A
condition written with [*] gets a refusal that names the loop instead.

A path that does not resolve is an error, and the message says where the
walk broke and what the object did have. The line is drawn at what the old
grammar could express: a bare var and a single var.field keep their silence,
because skills written under that promise live in other people's storage.

The shape of a reference now has ONE definition (RefPattern), built into
substitution, all four condition forms and the linter. The spellings had already
drifted apart.

Two behaviour changes came out of review:

• a broken path in an exit reason no longer cancels the exit. The reason is a
  caption; exit is how a skill hands the turn back, and a consumer tells that
  apart from a failure on purpose;
• set, switch and if now leave a trace when they fail and obey the step's
  on_error — they could not fail at all before, so neither half was wired up,
  while on_error was already being parsed for them.

2. The handbook travels with the module

handbook/, embedded and reachable the way the schema is:

skillengine.HandbookIndex()          // ~1.4 KB, fits in a prompt whole
skillengine.Handbook("flow-shape")   // a section, on demand

It existed and could not be reached: it lived in the ignored spec tree, so it
was in no repository, no module and no vendor/. Now it also cannot drift from
the engine — which it already had, within a day: its rule "a condition reads one
level" was made false by the first half of this PR.

Why forms rather than prose: the hint "if you need a subset, make it a separate
step" worked 0 times out of 16, while an example gets copied. Every section now
opens with a piece to copy. Why reachable rather than merely written: the old
pointer said "call the schema tool", which no skill had in its radius and no
skill-writing step could call anyway (tools: []).

Each linter rule that covers a handbook class carries its section id
(Rule.Handbook, Finding.Handbook) — a field, not a sentence glued to the
message, because whoever assembles the refusal decides what to do with it.

Two things the handbook is not, both guarded by tests: not a second source of
truth (a section naming a field the schema does not have is refused), and
not one installation's vocabulary — the tool names, telemetry fields,
clusters and skill names it arrived with are gone. Five published versions of
this library were retracted for exactly that class. The private names the guard
matches against are NOT in the test: they come from the list the git hooks
share, which is gitignored, and the test skips where it is absent.

The handbook is in Russian, like the failure reports it was written from; the
schema and both READMEs stay bilingual.