### wai-quantum 0.4.3: metered runs, placement by run, and the fabric wrapper

Additive. The default features, `full`, both implementations of the WebGPU member, and
every existing pin and digest are unchanged; runs, receipts and members stay unmetered
unless a caller supplies a meter.

- **Run meters.** `quantum_fabric::RunMeter`: `start` just before a run's first
  submission, `stop` after its last readback, returning the microjoules in the window and
  their `EnergyClass`, or none when the window cannot be attributed to the run alone. The
  trait is member-neutral, and no implementation ships in the crate. A reading reaches a
  result only when `check_label` accepts it; otherwise the run is unmetered (zero, no
  class). Every start is matched by one stop, a refused run's reading is discarded, and a
  meter that cannot start is never stopped.
- **The WebGPU member, metered.** `WebGpuMember::simulate_metered(c, start, meter)`
  returns the state with the accepted reading. Its window runs from the first submission
  to the last readback: the device's work, and the host's waits and copies between them;
  planning, buffer creation, the upload's staging and the conversion to a state vector
  are outside it, and the member's `detail` says so. A circuit refused
  before any submission opens no window. `member_metered(corpus, meter)` certifies as
  `member` does and gives each entry the figure its runs earn;
  `blocking::{simulate_metered, member_metered}`.
- **Placement figures from metered calibrations only.** `EnergyCalibration` (`new`,
  `add`, `runs`, `finish`) turns metered runs into a `KernelEntry::energy` figure: the
  total energy over the operations performed (`pair_updates`: one pair of amplitudes under
  one gate), in nanojoules rounded up, with the runs' class, whose uncertainty is the
  largest of the runs' plus what the rounding adds, over their windows together. An
  unmetered run, a refused label, a second class, or an uncertainty that no longer fits
  its field once the rounding is added leaves no figure.
  `detect_local_metered(corpus, meter)` gives the CPU reference its figures. Because
  `place` ranks a known figure before none, figures go on the CPU reference and on the
  members placement compares it with, or on none. `place` is unchanged; `place_for` and
  `Fabric` hold the rule themselves, and read figures on only some candidates as figures
  on none.
- **Placement for a run.** `place_for(members, kernel, required, predict_pj)` places by
  the least predicted picojoules when every candidate has a prediction, ties falling as
  in `place`. Otherwise predictions are not used, and the order is `place`'s, except that
  figures on only some candidates count as figures on none. Under synthetic models with a
  fixed cost per GPU run, a 3-qubit circuit stays on the CPU and a 24-qubit one goes to
  the GPU.
- **The fabric wrapper.** `Fabric` holds members with their `Runner`s (`CpuReference`,
  and `WebGpuMember` for its own implementation) and optional meters (`add`,
  `add_metered`, `set_model`, `order`, `run`). `run` places the circuit, falls back down
  the placement order when a member refuses with `MemberError::{TooWide, OutOfRange,
  Memory, Timeout, Device}` (`falls_back`), stops at an invalid circuit or a defect, and
  seals the `FabricReceipt` with the member and implementation that produced the result
  and its accepted reading. The refusals (`Refused`) are listed beside the receipt in
  `FabricRun`, or in `FabricError`; the receipt's signed bytes are unchanged.
  `WebGpuError` converts into `MemberError`. A runner states the member it is
  (`Runner::member_id`), and a run that reaches a member paired with a runner of another
  id is refused there as a defect, so a receipt cannot name a member that did not produce
  the result. `ready(future)` gives the output of a future that is ready on its first
  poll, which is how a native caller drives `run` without an executor; `&R` is a `Runner`
  and `&mut M` a `RunMeter`.
- **Tests.** CPU-side tests, native and under wasm32-wasip2 (each required by name in the
  `quantum-wasip2` job), cover the readings, the calibration, figures on both members or
  neither, `place_for`, the fallback, and metered fabric receipts. The device test
  `g13_metered_runs_and_the_fabric` runs the member under a test meter, calibrates it on
  random-v1 with the pinned digests, and runs the fabric with the member held to three
  qubits: a wider circuit falls back to the CPU reference, a narrower one is produced on
  the member and metered. It runs the tile implementation the same way, whose receipt
  names it, and requires a member paired with another member's runner, or with the other
  implementation's, to be refused. The member script requires it, and a fabric line per
  declared adapter.

