[wsttiger]

Adds cudaq_algorithms.LCUBlockEncoding, a generic linear-combination-of-unitaries
block encoding of H / alpha for a Hamiltonian written as a weighted sum of Hermitian
involutory unitaries H = sum_k c_k U_k. It assembles the merged primitives — coherent
alias sampling (AliasSamplingPrepare, #48) as PREPARE and unary iteration
(unary_iteration_kernels, #40) as SELECT — into the standard
U_A = PREPARE† · SELECT · PREPARE structure. alpha is the term one-norm sum_k |c_k|.

What the caller supplies. The term weights |c_k| and one SELECT body per term
describing U_k in the unary-iteration gate vocabulary (("x"|"y"|"z", target),
("sign",) for a negative c_k, and the free / AND-ladder work ops for multi-controlled
term unitaries). This keeps the primitive agnostic to how a problem decomposes into terms.
Every body op is validated at construction (known op, operand count, non-negative integer
operands, system targets below num_system, and a Hermitian product for Pauli-word
bodies) with a ValueError naming the term and op; integer parameters are not silently
truncated.

What it provides.

• The full BlockEncoding protocol, so it drives the existing Walk and QSVT
  consumers unchanged; encode_kernel / walk_kernel convenience factories with
  optional state_prep injection.
• The walk runs in the PREPARE frame, exactly as PauliLCU's does
  (W = PREPARE · R · PREPARE† · SELECT, real prepare_kernel / unprepare_kernel), so
  select_observable — the SELECT operator sum_k sign_k |k><k|_index ⊗ P_k, identity on
  the alias garbage — is derived from the bodies whenever every term is a Pauli word, and
  Walk.moment serves odd orders. Bodies in the extended vocabulary raise
  NotImplementedError there (even orders remain available).
• alpha, num_system, num_ancilla (= index + alias garbage + SELECT work), plus
  num_index / num_garbage / num_select_work, the term weights,
  discretized_weights, discretization_bound, and the underlying preparation.

Contracts / boundaries.

• Each U_k must be a Hermitian involution; SELECT is then a Hermitian involution and
  U_A is exactly self-adjoint on the all-|0…0> ancilla subspace (the domain every
  consumer supplies).
• Walk reflections cover the full ancilla register (garbage included): SELECT leaves
  the alias-PREPARE garbage entangled with the system, so an index-only reflection would
  misidentify the block.
• The alias PREPARE is pinned to the "select" QROM variant so SELECT can reuse its clean
  QROM ladder; PREPARE is never placed under cudaq.control (only SELECT and the
  reflection carry the external control).
• The ancilla register is index(m) + garbage(2m + 2mu + 2) + work qubits, so mu
  drives the width: the five-term, two-qubit test fixture is 22 qubits at mu = 4 and
  30 at the default mu = 8, sized for resource estimation rather than for the CI
  simulators.

Validation. tests/python/test_lcu_block_encoding.py (21 tests), green on CI
(cudaq 0.16) — exercised through a linear combination of Pauli words against independent
dense references, two ways: the circuit against the exactly-encoded matrix (alias-table
weights, dense unitaries) at simulator precision (1e-10), and the exactly-encoded matrix
against the ideal Hamiltonian within the derived discretization bound. Plus the one-norm,
the self-adjoint involution, Walk Chebyshev powers (T1, T2 of −H/alpha), the full
Walk.moments sequence (orders 0–5) and multi-qubit-word odd moments on small instances,
the controlled-apply and controlled walk-step control conventions (directly and through
Walk.controlled_roundtrip_kernel), a body on the SELECT work register (CZ), a QSVT phase
sequence against the signal model, protocol conformance, and the factory-boundary guards.

Docs. LCUBlockEncoding in the Python API reference and the block-encodings guide
(what the caller supplies, the ancilla formula, the moment frame); the protocol and
qubitization guide state the PREPARE-frame contract the odd-moment path relies on.

Follow-up (separate PR). PauliLCU opt-in params to route its PREPARE/SELECT through
this primitive (alias PREPARE + QROM/unary SELECT alongside today's exact
multiplexed-Ry + controlled-Pauli path); its term unitaries are Pauli words, so
select_observable / Walk.moment carry over by delegation.

[smcardleQ]

Approve overall; I think we should revisit the naming convention of 'PauliLCU' vs 'LCUBlockEncoding' (both of which assume Pauli terms). The real distinction is in how PREP and SEL are implemented. I think ideally there would be one 'PauliLCU' class, with arguments that choose how PREP and SEL are implemented.