feat(text): let text declare that it must fit its box (#170)

Closes the second Critical gap from the re-scored Remotion differential, and
the one the original audit called the most profitable reliability lever here.

Until now, a text that overflowed its box was reported and nothing more.
`apply_fixes` deliberately refuses `ContentOverflowsBox`, and its comment says
why: growing the box, shrinking the font and shortening the copy are all
legitimate, and picking one is not the validator's call. That reasoning holds
only while the engine has no way to shrink text at all. Given one, the
arbitration disappears — the author declares the intent, and a whole class of
generation failure stops existing.

`style.text-autofit` makes `text` and `gradient_text` reduce their font size
until they fit the resolved width and, where taffy defines one, the content
box height. `white-space: nowrap` still decides *whether* the text wraps;
autofit decides *at what size* — they compose rather than compete.
`auto_scroll` never interacts: codeblock and terminal do not read the field,
by construction rather than by convention.

Three hazards drove the design:

- **Measure and paint must agree.** This repository spent a whole chantier
  repairing divergences where `TextIntrinsic` measured one thing and the
  painter drew another, blinding the geometry pass to real overflow. One pure
  `resolve_text_autofit` is called with identical arguments from both sides,
  so the agreement is structural rather than coincidental — and the tests
  assert it rather than merely checking the render looks right.
- **The size must not drift.** Paint runs per frame. The resolution is fed
  the complete content, never the typewriter-truncated view, so a reveal
  cannot make the size oscillate mid-read. Asserted by rendering the same
  content at two instants and comparing pixels byte for byte.
- **Shrinking needs a floor**, or a visible defect is traded for a discreet
  one. The floor reuses `MIN_LEGIBLE_FONT_RATIO`, already calibrated by
  visual inspection, relocated into `rustmotion-core` so both sides share the
  one constant instead of inventing a second.

`rustmotion info` now reports each text's natural size, through the same
measurer the engine and the validator use.

The floor is pinned to a 1080-tall reference, because `IntrinsicMeasure`
cannot see the frame height and using the real one on the paint side alone
would reintroduce exactly the divergence above. On a taller canvas that floor
therefore sits below the legibility threshold, and a declared 120px shrinking
to ~13px on a 2160-tall frame would have passed the legibility check in
silence — the failure mode this feature exists to remove, not relocate.
`check_legibility` now warns in precisely that case, naming both numbers, and
stays quiet at 1080 where the two agree. The precise fix is a canvas-relative
floor on both sides; that needs the frame height plumbed into `TextIntrinsic`
and is tracked separately.

Author: LeadcodeDev

crates/rustmotion-cli/src/commands/geometry.rs

@@ -1,4 +1,6 @@
+use rustmotion::components::intrinsic::{GradientTextIntrinsic, TextIntrinsic};
 use rustmotion::components::{ChildComponent, Component};
+use rustmotion::core::engine::box_tree::{AvailableSpace, IntrinsicMeasure};
 use rustmotion::engine::animator::spring_rest_time;
 use rustmotion::engine::render::deserialize_children;
 use rustmotion::error::Result;
@@ -66,9 +68,132 @@ pub fn cmd_info(input: &PathBuf) -> Result<()> {
         }
     }
 
+    let text_sizes = collect_text_measurements(&scenario);
+    if !text_sizes.is_empty() {
+        println!("Text sizes:");
+        for report in &text_sizes {
+            println!("  {}", report.describe());
+        }
+    }
+
     Ok(())
 }
 
+/// "Quelle largeur/hauteur fait ce texte, à cette taille, dans cette
+/// police" (text-autofit workstream, lot text-autofit) exposed the same way
+/// `rustmotion info` already exposes spring settle times (see
+/// `SpringReport` above) rather than as a bespoke, separate command:
+/// `rustmotion info` walks the scenario and reports; this adds one more
+/// thing it reports.
+///
+/// The measurement is the natural (unconstrained) size at the declared
+/// `font-size`/family — via `TextIntrinsic`/`GradientTextIntrinsic`, the
+/// exact same Skia-backed measurer the layout engine and the geometry
+/// validator use, so this is never a second, independently-drifting
+/// estimate of what the same text measures elsewhere.
+struct TextMeasurement {
+    label: String,
+    kind: &'static str,
+    preview: String,
+    font_size: f32,
+    natural_width: f32,
+    natural_height: f32,
+    autofit: bool,
+}
+
+impl TextMeasurement {
+    fn describe(&self) -> String {
+        let autofit_note = if self.autofit {
+            " (text-autofit: true — shrinks further if its box is smaller than this)"
+        } else {
+            ""
+        };
+        format!(
+            "{}: {} \"{}\" @ {:.0}px → natural {:.0}×{:.0}px{}",
+            self.label,
+            self.kind,
+            self.preview,
+            self.font_size,
+            self.natural_width,
+            self.natural_height,
+            autofit_note,
+        )
+    }
+}
+
+fn collect_text_measurements(scenario: &ResolvedScenario) -> Vec<TextMeasurement> {
+    let mut out = Vec::new();
+    for (vi, view) in scenario.views.iter().enumerate() {
+        for (si, scene) in view.scenes.iter().enumerate() {
+            let children = deserialize_children(scene);
+            let path = format!("view {} / scene {}", vi + 1, si + 1);
+            collect_text_measurements_in_children(&children, &path, &mut out);
+        }
+    }
+    out
+}
+
+fn collect_text_measurements_in_children(
+    children: &[ChildComponent],
+    path: &str,
+    out: &mut Vec<TextMeasurement>,
+) {
+    let natural = (AvailableSpace::MaxContent, AvailableSpace::MaxContent);
+    for (i, child) in children.iter().enumerate() {
+        let p = format!("{path} / layer {}", i + 1);
+        match &child.component {
+            Component::Text(t) => {
+                let (w, h) = TextIntrinsic::from_text(t).measure((None, None), natural);
+                out.push(TextMeasurement {
+                    label: p.clone(),
+                    kind: "text",
+                    preview: preview(&t.content),
+                    font_size: t.style.font_size_px_or(48.0),
+                    natural_width: w,
+                    natural_height: h,
+                    autofit: matches!(t.style.text_autofit, Some(true)),
+                });
+            }
+            Component::GradientText(t) => {
+                let (w, h) =
+                    GradientTextIntrinsic::from_gradient_text(t).measure((None, None), natural);
+                out.push(TextMeasurement {
+                    label: p.clone(),
+                    kind: "gradient_text",
+                    preview: preview(&t.content),
+                    font_size: t.style.font_size_px_or(48.0),
+                    natural_width: w,
+                    natural_height: h,
+                    autofit: matches!(t.style.text_autofit, Some(true)),
+                });
+            }
+            _ => {}
+        }
+        match &child.component {
+            Component::Card(c) => collect_text_measurements_in_children(&c.children, &p, out),
+            Component::Flex(c) => collect_text_measurements_in_children(&c.children, &p, out),
+            Component::Grid(c) => collect_text_measurements_in_children(&c.children, &p, out),
+            Component::Positioned(c) => collect_text_measurements_in_children(&c.children, &p, out),
+            Component::Container(c) => collect_text_measurements_in_children(&c.children, &p, out),
+            _ => {}
+        }
+    }
+}
+
+/// Truncate a long content string for a single-line report — the full
+/// content is already visible in the source scenario file; this is a label,
+/// not a transcript.
+fn preview(content: &str) -> String {
+    const MAX_CHARS: usize = 40;
+    let char_count = content.chars().count();
+    if char_count <= MAX_CHARS {
+        content.to_string()
+    } else {
+        let truncated: String = content.chars().take(MAX_CHARS).collect();
+        format!("{truncated}…")
+    }
+}
+
 /// Where a `SpringConfig` was found, and the settle time computed for it —
 /// the "measure du repos" issue #167 lot E asks `rustmotion info` to
 /// surface, so an author can size the enclosing animation's `duration`