Replace the layout engine style decode layer with lazy CV views - #10961

Width, height, the min/max sizes, flex-basis and column-width now come
out of StyleValues as &'static ComputedSize payload references carrying
the lazy CSS::Size-style method surface, instead of being eagerly
re-encoded into FfiSizeValue on every read. The StyleValues reader is
pinned to the 'static payload lifetime the arena already guarantees
for a pass, so the references are as freely storable as the decoded
values were, and the sizing arms of SizeField and direct_size are gone.

Consumers change mechanically: contains_percentage becomes a method
call, the FfiSizeKind comparisons become kind predicates on the stored
kind, the table percentage-contribution paths read the stored
percentage through as_fraction() with the same multiplication order,
and the fit-content keyword-versus-argument distinction is now the
presence of the argument's style value rather than a decoded flag.
Substituted auto sizes in the treat-as-auto replaced sizing paths
share one static auto value. The FfiSizeValue kind predicates lose
their last consumers here and are deleted; the remaining decode users
only need is_auto and to_px.

Margin and padding reads now hand out &'static
ComputedLengthPercentageOrAuto references into the surround style group
payload instead of decoding each side into FfiSizeValue, following the
same shape as the sizing properties. The margin and padding arms of
SizeField and direct_size are gone; only the four inset fields still
route through the decode path, pending the anchor-inset rework.

Every consumer already reads these values through is_auto() and
to_px(), so call sites are unchanged apart from the absolutely
positioned box solver, where the shared resolve_or_auto helper splits
into a margin variant while insets still carry the decoded
representation.

The four inset properties were the last style reads flowing through
size_value: they consult the per-LayoutState anchor-inset store before
the payload, so a plain payload reference cannot represent them. They
now come out of StyleValues as InsetValue, a three-state view that
makes the store's masking rules structural: FromStyle borrows the
stored computed value, BareAnchor borrows the store-owned calculated
wrapper for a bare anchor() inset, and Resolved carries the px-or-auto
value anchor resolution wrote back, which by construction masks both
anchor representations and answers contains_anchor_function() with
false, preserving the abspos engine's early-out on re-entry.

The anchor-inset store now stores that resolved value directly rather
than an FfiSizeValue, indexed by a dedicated InsetField enum, and the
abspos engine reads anchor-bearing calc trees through
anchor_bearing_calculated() instead of a raw pointer field. This
removes size_value, the inset arms of SizeField and direct_size, and
the decode helper for length-percentage-or-auto values.

Row and column gaps now come out of StyleValues as &'static
ComputedGap references, where normal answers is_normal() and resolves
to zero exactly as the decoded auto placeholder did. The SVG x and y
properties, text-indent and the vertical-align offset hand out
borrowed LengthPercentageRef views over their retained style values.

These were the last fields flowing through the SizeField dispatch, so
the enum, direct_size and the accessor macro built around them are
gone, and FfiSizeValue keeps only the constructors and to_px that the
grid track decode still uses.

Grid track breadths and sizing functions were the last holders of
FfiSizeValue: every stored track size was eagerly decoded into the
flat struct, and synthesized fixed tracks (collapsed tracks, gap
tracks, fixed subgrid tracks) forged one from a px value.
GridTrackBreadth is now an enum borrowing the computed size straight
from the grid style group payload, TrackSizingFunction::Fixed carries
that payload reference, and a dedicated FixedPx variant models the
synthesized tracks, which never contain percentages and resolve to
their stored px size exactly as the forged values did. TrackListSource
and the track-expansion helpers now state the 'static payload lifetime
the grid style reader already guarantees.

With the grid decode gone, FfiSizeValue, FfiSizeKind and the
decode_length_percentage/decode_computed_size helpers have no users
left and are deleted: the wire format that once carried style reads
across the FFI callback boundary is fully replaced by lazy views over
the Rust-native computed values. ComputedSize and its handle gain a
Debug derive so the grid track types keep theirs.

Every layout style read now goes through the lazy payload views, so
the dead-code allowance that covered readers landing ahead of their
consumers is gone, along with the few predicate methods that ended up
with no callers outside the unit tests.

With every style read handing out payload references, StyleReader had
become a payload multiplexer that StyleValues merely wrapped, and each
reader-only context (tree building, node facts) juggled a second type
for the same node. StyleValues now owns the payload pointer and the
group accessors directly, generic over the payload lifetime instead of
pinned to 'static: within a pass the payloads still come in 'static
and the anchor-inset store bounds the view; outside a pass,
from_payloads builds a store-less reader whose inset accessors are the
one unavailable surface, matching what StyleReader could not answer
either. The reader-only fact methods (display facts, the
block-formatting-context predicate) move along, and
style_reader_if_styled becomes style_values_if_styled.

The 'static claims that leaked into consumers shrink accordingly:
flex's UsedFlexBasis carries the pass lifetime, and the grid and
sizing helpers take plain references. Grid track expansion keeps its
'static payload references by reading the grid style group through a
store-less reader over the pass-blessed payloads.

The property accessors on StyleValues — which field of which style
group carries width, the margins, tab-size and the rest — are
computed-values knowledge, the Rust twin of the accessor layer in the
C++ ComputedValues.h, so they now live beside the payload types as
ComputedValuesView in computed_value_views.rs. The view owns the group
pointer array, the typed group getters and every pure read, including
the display facts and the style-only block-formatting-context
predicate, with the group indices moving into computed_value_types.rs
where the C++ static asserts keep pinning them through the same
generated header.

StyleValues shrinks to the layout pass state the css module cannot
know about — the anchor-inset store behind the four inset reads and
the line builder's vertical-align keyword substitution — and derefs to
the view for everything else, so call sites are unchanged. This also
undoes the optional-store compromise from folding StyleReader away:
contexts outside a pass (tree building, node facts) now hold a plain
ComputedValuesView with no inset surface at all, and the pass view
carries the store unconditionally again.

The scalar_accessors table already expresses renamed projections, so
the hand-written boolean and scalar accessors that merely rename a
group field (has_column_count, the containment and text-indent flags,
the tab-size triple, the font metrics, flex_basis_is_content and the
natural-aspect-ratio flag) join it instead of restating the same shape
one method at a time. A reference_accessors sibling covers the
by-reference projections — the six sizing properties, column-width,
margins, paddings and gaps — whose returns borrow the group payload
for the view's lifetime, which the scalar macro's unnamed-lifetime
impl block cannot express.

The accessors that remain hand-written all have real bodies: the
computed predicates, the fit-content and flex-basis substitutions, the
expect-carrying length-percentage chains and the unit conversions.