### wai-quantum: any exercise is checked as a lesson is

`engine::course::check_exercise` checks a program against an exercise document in the course's form
(`wai.quantum.exercise/1`): the same verdicts, constraints and words as a lesson's check, with `lesson` null. It is how
a task that is not in the course is held to what it must do, the first step toward the job service writing a program
for an intent and checking each attempt. `check` now looks up its lesson and calls it, and its answers are the same
bytes for a program that passes.
- **The exercise is read first.** `engine::course::exercise_form` holds a document to the form a lesson's exercise is
  held to, as far as a check reads it, and `check_exercise` refuses what it refuses before anything runs: a bound that
  is not whole numbers (`{"max": 1.5}`, `{"max": "0"}`, a bare number), a constraint or a field the course does not
  name, a job with more than shots, seed and noise (so a task cannot ask for a repair the transcript does not show),
  more than 16 cases (`MOST_CASES`) or 8 intents in one place (`MOST_INTENTS`). Before, such a constraint held
  vacuously, an unknown one was dropped, and a job that was not an object stopped the check with a panic.
- **Every case binds its inputs.** A program that does not declare an input a case gives is refused in that case
  (`Q114`), where it was run without the input: the bit-flip code's lesson passed with no flip at all. A case whose
  `intent` is null takes the exercise's, as one with none does.
- **The constraints hold in every case**, not only the first: a gate one case alone adds is counted, and the case is
  named in what went wrong.
- **An injected error is corrected from the qubits.** A new constraint, `inject`, names the input whose value is the
  qubit an error flips: the cases' programs may differ in that one x alone, so the program cannot read the error and
  must find and correct it with its quantum operations. Another, `qubits` (`{"max": n}`), bounds the qubits a program
  declares. The bit-flip and syndrome lessons set both: before, a program that declared the error and never applied
  it passed the bit-flip lesson, and one that branched on it classically passed the syndrome lesson.
- **A T count counts T gates however they are written:** a `p` or `rz` by an odd multiple of π/4 counts one, a
  Clifford gate none, and any other gate (a rotation by another angle, a Toffoli) does not hold to a T count, since
  its count is not fixed. A gate on three qubits does not hold to a count of two-qubit gates. Before, `t_count`
  counted gate names, so the t-count lesson passed with every T written as `p(pi/4)`.
- **Breaking:** `api:rust:wai_quantum::engine::course::CONSTRAINTS`: the array gains `qubits` and `inject`, so its length goes from 6 to 8. Code that names the array's length should read `CONSTRAINTS.len()`; code that iterates it needs no change.
