Virtualization supports variable-height items

[ilonatommy]

High level requirements:
#25058 (comment)

This is WIP. Sample changes are not part of the fix.
Visualization of how the sample works with the initial implementation (scrolling with the scroll & jumps with Ctrl + Home or Ctrl + End):

Working-Variable-Height.mp4

Description

Scenarios that we should consider (test/document/log as a separate issue):

1. Dynamic Height Changes After Initial Render - ✅ covered, test added (DynamicContent_ItemHeightChangesUpdateLayout)
   If an item's height changes after it's been measured (e.g., image loads, async content expands, user expands an accordion), the cached measurement should not become stale. If an item that is out of view expands (e.g. item 2 when view is focused on items 10-14), current view does not shift.

2. Window/Container Resize - ✅ covered, tests added (VariableHeight_ContainerResizeWorks)
   When the container width changes, text wrapping changes, causing item heights to change. The cached measurements become invalid.

3. Extreme Height Variance - ✅ covered, tests changed to cover x100 variation.
   If items vary from 20px to 2000px, the average-based estimation for un-measured items can be wildly inaccurate, causing large scroll jumps.

4. Memory Pressure from Measurement Cache
   _measuredHeights dictionary grows unbounded. With 1 million items and user scrolling through all of them, we store 1 million floats. Very large datasets or long user sessions with extensive scrolling might be problematic.

5. Scroll Position Stability (Scroll Anchoring)
   When spacer heights recalculate after measurements update, the browser may "jump" even with overflow-anchor: none. Users might see content shift.

6. ItemsProvider with Variable Heights - ✅ covered, async tests added, slow big load tested manually (see the video)
   Currently we test with Items (synchronous). When using async ItemsProvider, measurements happen as items load. If loading is slow, we might calculate wrong positions.

Async-delay.mp4

7. CSS Transform/Scale on Container - ✅ covered in VariableHeightAsync_CanScrollThroughItems
   We have getCumulativeScaleFactor() but it only checks transform matrix. Other CSS that affects layout (zoom, perspective) might not be handled.

8. RTL (Right-to-Left) Layout - ✅ covered in VariableHeightAsync_CanScrollThroughItems
   Height calculations should be unaffected, but scroll behavior and spacer positioning might differ.

9. Horizontal Virtualization Interaction
   If someone uses Virtualize inside a horizontal scroll container, our height-based logic doesn't apply. This is probably out of scope, but worth documenting.

10. Placeholder Height Mismatch - ✅ covered by the walking average that only initially falls back to ItemSize
    Placeholders use ItemSize for height. If actual items are much taller/shorter, there's a visual jump when the real item replaces the placeholder. What would happen with placeholders with heights very different from actual content?

11. First Item at Non-Zero Index
    Related to issue Virtualize first render has upper spacer #64029. If the first visible item isn't index 0, measurements may start from wrong indices.

12. Empty or Single-Item Lists - ✅ covered in VariableHeightAsync_SmallItemCountsWork

13. Items Collection Mutations - ✅ covered, added test VariableHeightAsync_CollectionMutationWorks
    If items are added/removed from the Items collection, cached measurements reference stale indices. Adding items at beginning, removing items in middle etc.

14. Test on Multiple Browsers ✅
    Different browsers may fire callbacks at slightly different thresholds or with different batching. Chrome, Firefox, Safari all throttle scroll events differently. getBoundingClientRect() returns sub-pixel values that differ by browser. scrollTop may round differently (integer vs float). IntersectionObserver is a core of virtualization feature. it's mostly standarized acros browsers but edge cases might exist. It would be good to be aware of them.

Result: Tested on Chrome, Firefox, and WebKit — all browsers behave consistently for virtualization: same visible item counts, exact scroll position accuracy, and integer pixel height measurements. The only notable difference is WebKit's 2x device pixel ratio (simulating Retina), which results in one additional sub-pixel item being rendered (22 vs 21).

Contributes to #25058.