chore(autodiff): add a generic lowering reference consumer for tests

[AlekseiChirkovVention]

Add the single shared test-only backend that two features need to prove the lowering seam is
generic and that an expanded artifact computes what the unexpanded one does.

Goal

Create one generic reference consumer in the test tree, over the one dense-array execution
semantics that already exists, rather than letting each feature grow its own.

It supplies a handler registry limited to constants, matmul, and multiply; an opt-in variant
that adds trivial reshape; a reduction-capable control registry; and a wrapper that records
every handler invocation in call order.

Acceptance criteria

• Exactly one shared generic reference consumer exists in the test tree afterwards, and the
  narrow existing proof of the lowering seam is left untouched.
• The dense-array dispatcher executes a constant node to an array of the descriptor's shape,
  dtype, and value.
• The limited-operation registry resolves handlers for exactly constants, matmul, and
  multiply, and rejects reshape, mean, broadcast, and division.
• The opt-in variant additionally resolves reshape, and its handler rejects a reshape that
  changes the element count.
• The control registry lowers mean, broadcast, and division to the same values the dispatcher
  produces for the same nodes.
• The recording registry records every handler invocation in call order.

Test evidence

Level: unit. Tests first: the failing set landed in e4b2b05, before the module it
imports existed; 7946050 made it pass. The test file is byte-identical between the two.

py/tests/test_autodiff_reference_consumer_smoke.py — 16 test functions, 19 cases, all
passing. Full autodiff suite: 741 passed, 2 skipped. Broad non-integration suite: 992 passed,
9 failed, 1 skipped — the 9 are pre-existing and unrelated to this branch (7 require the
unbuilt local backend, 2 are style guards on a file this branch does not touch).

Design notes for the reviewer

Two properties here are load-bearing for later branches in this series, and both are easy to
get subtly wrong:

Every handler delegates to the existing dispatcher instead of restating operator meaning.
That is what keeps one execution semantics behind both the node-level executor and the
lowering-level registry. If the registries recomputed matmul or mean themselves, the two could
drift into agreeing on a wrong answer, and the equivalence proof that depends on this control
would quietly become worthless. The trivial-reshape handler is the one exception, and it only
adds an element-count check before delegating.

The invocation recorder records at handler call time, not at lookup time. A later branch
proves that a backend missing a required handler is rejected before any handler runs, by
asserting this record stayed empty. A lookup-time recorder would log entries in exactly the
case the proof needs empty, and that test would then pass by accident.

The constant-node dtype mapping is explicit and total over the two differentiable dtypes; an
unmapped dtype raises rather than widening to a default, for the same reason — a silent
widening would let a later numerical assertion pass for the wrong reason.

Stack position

Stack position 2 of 8 — based on feat/generated-constant-operator.

Cannot merge into main before feat/generated-constant-operator, whose constant operator
and descriptor reader this branch consumes.