responsive fluid/physical scaling, widget-API stabilization, and perf guardrails

Responsive scaling. ltk now offers two first-class ways to size a UI so it adapts across screens, chosen per process via `WidgetScaling { Fluid, Physical }` (`set_widget_scaling` / `widget_scaling`, default `Fluid`). Fluid sizing (`Length::fluid( px )`) makes a design pixel a proportion of the surface's smaller side, calibrated against a reference width (`set_fluid_reference` / `fluid_reference`, 412 px default) and bounded by `FLUID_MIN` / `FLUID_MAX`; physical sizing (`Length::dp( px )`) is a constant-physical-size pixel scaled by display density (`set_density` / `density`). `Length` gains `orient( portrait, landscape )` — resolve one value in portrait, another in landscape — plus `widget( px )`, which picks fluid or dp per the active mode. Canvas exposes `geom_px` (geometry, resolved in physical layout space) and `font_px` (font size, bridging logical / physical per mode) so widgets and apps share one resolution path. Note the rename: `set_design_reference` / `design_reference` became `set_fluid_reference` / `fluid_reference`, and `Length::dp` changed meaning — the old surface-proportional behaviour now lives on `Length::fluid`.
Widgets. Every stock widget resolves its default geometry and font through the widget-scaling mode instead of frozen pixels, so a whole UI scales coherently without per-call units. New size builders where they were missing: `button` gains `font_size` / `height`, `text_edit` gains `height` / `font_size_fluid`, `separator` gains `pad_v`, and assorted widgets accept a `Length` where they previously took only `f32`.
Overlays. `OverlaySpec::size` is now `( Length, Length )` instead of `( u32, u32 )`, resolved against the main surface when the overlay is materialized, so overlays can scale with the display; `Length::px( … )` reproduces the old fixed sizing.
API stabilization (toward 1.0). Widget struct fields are now `pub( crate )` — they are configured through builders, not field access — except the value / state types apps genuinely read or construct (`Time`, `Date`, `ComboState`), which stay public. The internal `test_support` helpers move behind a `test-support` Cargo feature (off by default, so third-party builds never see them; ltk's own `make test` enables it). `Separator` drops its `0.0`-means-mode sentinel for `Option<Length>`, so an explicit `pad_v( 0.0 )` is a real flush divider distinct from the mode-following default.
Performance guardrails. Opt-in diagnostics via `LTK_PERF_WARN=1` warn about stuck animations, sustained software-render animation, and low `poll_interval`; software-rendered animation is capped near 30 Hz to spare CPU on machines that fall back off EGL. Apps can override the cap with `App::cap_software_animation`.
Docs and build. The two scaling modes are documented in README, onboarding and architecture, with the earlier gradient / backdrop doc drift cleaned up. The Makefile now ships the `locales/` directory into the packaged crate (fixing i18n keys rendering raw for downstreams), builds the new `responsive` example, and runs tests with `--features test-support`.

src/widget/tooltip/mod.rs

@@ -41,7 +41,7 @@ use std::collections::hash_map::DefaultHasher;
 use std::hash::{ Hash, Hasher };
 
 use crate::app::{ Anchor, Layer, OverlayId, OverlaySpec };
-use crate::types::{ Color, WidgetId };
+use crate::types::{ Color, Length, WidgetId };
 use super::Element;
 
 mod theme;
@@ -53,20 +53,20 @@ mod tests;
 pub struct Tooltip<Msg: Clone>
 {
 	/// Body text rendered inside the tooltip.
-	pub message:    String,
+	pub( crate ) message:    String,
 	/// Stable identifier of the widget the popup anchors to. The widget
 	/// must have been built with `.id( anchor_id )` so the runtime can
 	/// look its rect up in the previous frame's layout snapshot.
-	pub anchor_id:  WidgetId,
+	pub( crate ) anchor_id:  WidgetId,
 	/// Maximum width (logical pixels). The tooltip is single-line; long
 	/// strings are clipped at the surface boundary.
-	pub max_width:  u32,
+	pub( crate ) max_width:  u32,
 	/// Optional override for the tooltip background colour.
-	pub bg:         Option<Color>,
+	pub( crate ) bg:         Option<Color>,
 	/// Optional override for the body text colour.
-	pub fg:         Option<Color>,
+	pub( crate ) fg:         Option<Color>,
 	/// Optional message fired when the user taps outside the popup.
-	pub on_dismiss: Option<Msg>,
+	pub( crate ) on_dismiss: Option<Msg>,
 }
 
 impl<Msg: Clone + 'static> Tooltip<Msg>
@@ -129,12 +129,12 @@ impl<Msg: Clone + 'static> Tooltip<Msg>
 
 		let body: Element<Msg> = container(
 				text( self.message.clone() )
-					.size( theme::FONT_SIZE )
+					.size( Length::widget( theme::FONT_SIZE ) )
 					.color( fg )
 			)
 			.background( bg )
-			.padding_h( theme::PAD_H )
-			.padding_v( theme::PAD_V )
+			.padding_h( Length::widget( theme::PAD_H ) )
+			.padding_v( Length::widget( theme::PAD_V ) )
 			.radius( theme::RADIUS )
 			.into();
 
@@ -143,7 +143,9 @@ impl<Msg: Clone + 'static> Tooltip<Msg>
 			id:                 overlay_id,
 			layer:              Layer::Overlay,
 			anchor:             Anchor::TOP,
-			size:               ( self.max_width, theme::HEIGHT ),
+			// Height scales with the display so the fluid text always fits; the
+			// caller-set max width stays fixed so wrapping is predictable.
+			size:               ( Length::px( self.max_width as f32 ), Length::widget( theme::HEIGHT as f32 ) ),
 			exclusive_zone:     0,
 			keyboard_exclusive: false,
 			input_region:       None,