fix(symmetry): make a symmetry tag match the buffer it is attached to

[spMohanty]

Summary

Aligns symmetry metadata with the buffers it describes, and adds a second
symmetrization mode.

Symmetry validation accepts data that is symmetric within a tolerance, while the
cost model reads the tag it grants as exact — it prices every position in an
orbit after the first as a redundant degree of freedom and does not read the
buffer again. The two readings disagree for any buffer whose orbit entries merely
agree closely:

import numpy as np
import flopscope as flops

G = flops.SymmetryGroup.symmetric(axes=(0, 1))
x = np.array([[1.0, 2.0], [9.0, 3.0]])            # not symmetric: 2 vs 9

with flops.BudgetContext(flop_budget=10**9):
    flops.as_symmetric(x, symmetry=G)             # SymmetryError, as expected

    t = 2.0**-40                                  # same claim, smaller numbers
    tagged = flops.as_symmetric(x * t, symmetry=G)   # accepted
    restored = np.asarray(tagged * (1.0 / t))        # tag propagates

before:  restored = [[1.0, 2.0], [9.0, 3.0]]      orbit entries equal: False
after:   restored = [[1.0, 2.0], [2.0, 3.0]]      orbit entries equal: True

as_symmetric and the public SymmetricTensor constructor now copy one
representative per orbit before attaching the tag, so the tag matches the buffer.
Data that is already exactly invariant is returned unchanged, which keeps the
zero-copy view semantics and out= layouts of the common case. Charges are
unchanged: the copy is folded into the existing validation cost.

Also in this change

• symmetrize gains mode=. The default, "reynolds-projection", is the
  existing behaviour and is unchanged in both result and price. The new
  "canonical-copy" keeps each orbit's lexicographically first entry instead of
  averaging the orbit, bills numel(data) — the rate every other materializing
  copy pays — and preserves the input dtype rather than promoting to float64. It
  reads only the group's generators, so it stays available for groups too large
  to enumerate. fnp.random.symmetric takes the same argument.

• Reynolds symmetrization refuses an unenumerable group before charging for
  it. symmetrize and fnp.random.symmetric previously computed a projection
  cost from a closed-form group order, charged it, and only then hit the
  enumeration limit. They now raise ValueError first, naming
  mode="canonical-copy", and the refused call costs nothing.

• full and full_like no longer infer symmetry from shape when fill_value
  is not a scalar. The inferred group describes a constant fill; a broadcast
  array fill writes distinct values into positions it would otherwise report as
  redundant.

• Symmetry attachment inside the package routes through
  wrap_with_derived_symmetry. Trust is anchored to
  wrap_with_trusted_symmetry alone, and the two sites that cannot inherit a
  counted frame name it explicitly.

Billing

as_symmetric and is_symmetric are unchanged, verified against the existing
k * (7n - 1) formula and identical whether or not the copy runs.
symmetrize(mode="canonical-copy") bills numel. Reynolds pricing is untouched.
A 32-operation differential against the previous release shows no other change.

One narrow rise: a non-scalar fill_value into a shape with two or more
equal-length axes loses a tag its data did not support, so its results are priced
as the dense arrays they are. Any other shape was never tagged and is unchanged.
Details in the CHANGELOG.

Tests

tests/test_symmetry_canonicalization.py (77 tests) covers exact invariance
under symmetric, cyclic, dihedral and generator-defined groups; the
representative rule; dtype preservation across float, integer, boolean and
complex; orbit-map cache keying, byte bound and eviction; and that trusted
propagation adds no per-operation cost. Full suite green.