Missing casts: `angle()` narrowing, `angle(float)`, and `int[n](bit[n])`

[TheGupta2012]

Limitation

The allowed casts table permits float -> angle
and bit -> int, and the
floating-point numbers section shows
an angle narrowed to a smaller width with angle(...).

pyqasm rejects all three.

Example QASM failure

Narrowing an angle — the spec's own example:

OPENQASM 3.0;
angle[20] a = pi / 2;
angle[20] b = pi;
angle[10] c;
c = angle(a + b);        // cast to angle[10]

ValidationError: Invalid initialization value for variable 'c'

float -> angle, marked Yes in the cast table:

OPENQASM 3.0;
float[64] f = 1.0;
angle[20] a = angle(f);
// ValidationError: Invalid initialization value for variable 'a'

bit -> int, also marked Yes:

OPENQASM 3.0;
bit[8] b = "00000101";
int[8] i = int[8](b);
// ValidationError: Invalid initialization value for variable 'i'

Casts that already work: int[n](float), uint(float), bool(int), bit[n](int).

Change Requested

1. angle(x) and angle[n](x) where x is a float or an angle, applying the spec's
   fixed-point semantics: an angle[n] represents a value in [0, 2π) with n bits of
   precision, so narrowing truncates the low-order bits.
2. int[n](b) and uint[n](b) where b is a bit[n], interpreting the bit register as the
   integer's binary representation.
3. A cast the spec's table forbids must raise a ValidationError naming both types, rather
   than the current generic "Invalid initialization value" message.

Not in scope

• float(duration) — the cast table marks this No; pyqasm's current rejection is correct.
• float(angle) — the table also marks this No, though the spec's own comparison example uses
  it. pyqasm currently accepts it. Worth raising upstream on openqasm/openqasm to settle
  the inconsistency before changing behaviour either way.

Implementation Details

• Cast handling is in Qasm3ExprEvaluator (src/pyqasm/expressions.py) together with the type
  maps in src/pyqasm/maps/expressions.py.
• Angle semantics are the substantive part. An angle[n] is a fixed-point value: the stored
  integer is round(value / (2π) * 2**n), and narrowing from angle[m] to angle[n] with
  n < m truncates. Implementing that as an explicit representation makes the spec's worked
  results — 7 * (pi / 8) as angle[4] being "0111" — directly assertable in tests.
• bit -> int depends on the width-carrying bit representation from the bit[n] operators
  issue; sequence that one first.
• Encoding the spec's cast table as an explicit (from_type, to_type) -> allowed map gives
  correct rejection messages for free and documents the supported surface in one readable
  place.
• Tests: tests/qasm3/test_casting.py — each newly supported cast with its expected value,
  angle narrowing against the spec's worked bit patterns, and a forbidden cast asserting a
  ValidationError that names both types.