Column block: Migrate width to dimensions block support - #76684

A width set on `core/column` in theme.json or Global Styles had no effect.
Three things were missing.

`settings.blocks.core/column.dimensions.width` is now enabled in
`lib/theme.json`. Block supports only ever disable that setting, so
without it the Dimensions panel never rendered the width control.

`WP_Theme_JSON` and the style engine rewrite the generated `width`
declaration to `flex-basis` and add `flex-grow: 0`, because a column sizes
itself within a flex container.

The default flex sizing in `style.scss` now uses the same `:root :where()`
format as the global styles output, so the generated rules win on source
order. It previously sat at a higher specificity and overrode them.

The Row and Grid transforms still read and wrote the old `width`
attribute, so a column's width was dropped when converting in either
direction.

They also copy a column's styles onto the Group they create. Now that the
width lives in `style.dimensions.width` it rode along, and rendered as a
`width` on the Group. It is stripped instead, matching the previous
behaviour: Grid drops it, Row converts it to the child layout's
`flexSize`.

Sets a width from the Dimensions panel and asserts it is written to
`style.dimensions.width`. The existing width redistribution tests are
updated to the new attribute shape.

Column widths set on a block style variation within a breakpoint were
output as `width` rather than `flex-basis`, so they had no effect. The
breakpoint loop inside the variation branch computes its declarations on
its own path and never reached the existing conversion.

Adds the missing call site, plus PHP coverage for column widths at the
block level, within a breakpoint, and on a style variation.

The column width was extracted by deleting `dimensions.width` from the
node's styles. Those styles are a live reference into the global styles
tree, so the render pass mutated its caller's data.

Replaces it with a helper that rewrites the generated declarations
instead, mirroring `WP_Theme_JSON_Gutenberg::update_column_width_declarations`.
Every node type passes through `renderStylesNode`, so responsive and
style variation widths are covered by the one call site.

…support

Tracks the Core PR that backports the `WP_Theme_JSON` changes.

`getDimensionPresetCssVar` built the custom property from the raw slug,
but both the PHP and JS sides kebab-case it when they declare it. A slug
such as `wideColumn` or `size2` therefore resolved to a property that was
never declared, and whatever consumed it got no value.

Delegates to the style engine's `getCSSValueFromRawStyle`, which already
handles the conversion, rather than parsing the prefix again here.

A width set for a viewport state on a single column was output as
`width`, which does nothing to a flex child, so the value never took
effect. Theme.json state styles already converted; this is the instance
path, on the front end in `gutenberg_add_block_state_style_rule` and in
the editor's state CSS.

The conversion was a private method on `WP_Theme_JSON_Gutenberg`, which
`states.php` cannot reach, and a module-private function in the global
styles engine, which `block-editor` cannot import. Moves the PHP copy to
`lib/block-supports/dimensions.php` as a plain function and exports the
JS mirror, so each language has one place both callers share.

Once a column width is set in theme.json or Global Styles, every column
inherits it and there is no way to say "no width, take the remaining
space". Adds width presets for the column, following the pattern
`core/button` already uses, including a Fill preset that outputs
`flex-basis: 0` and `flex-grow: 1`.

Columns with a width still keep it and do not grow, so a row of fixed,
fill, fixed behaves as expected. Only a filling column writes
`flex-grow` inline; the rest rely on the existing `[style*="flex-basis"]`
rule, which leaves existing markup unchanged.

The Fill preset's size is `auto` rather than `0` because the width
control resolves a preset to its size before matching it back to a slug,
and `0` is the sentinel for its built-in "None" option. With a size of
`0` the control showed None instead of Fill.

This turns the column's Width control from a plain unit input into a
preset control.

Below 782px the columns stylesheet forces `flex-basis: 100% !important`
so columns stack. Block instance state styles are also `!important`, so
the two compete inside the important tier, where the stacking rule's
three classes beat the state rule's single hashed class. A width set for
the mobile or tablet state was therefore discarded.

Wraps the stacking selector in `:root :where()`, so it sits at the same
specificity as the rest of the global styles output and a state width
wins on source order. State styles always print after the block library
stylesheet, on the front end and in the editor canvas.

Stacking itself is unchanged: `!important` still beats the inline width
and any global styles width, because important beats normal whatever the
specificity.