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/window_button/mod.rs

@@ -38,23 +38,24 @@ pub enum WindowButtonKind
 pub struct WindowButton<Msg: Clone>
 {
 	/// Which decoration role this button paints.
-	pub kind:      WindowButtonKind,
+	pub( crate ) kind:      WindowButtonKind,
 	/// Message emitted on activation. `None` greys the button and skips
 	/// the hover / pressed surface — useful for "maximize disabled" on
 	/// fixed-size windows.
-	pub on_press:  Option<Msg>,
-	/// Square hit-target size in logical pixels. Clamped to a 20 px floor
-	/// by [`Self::size`] so the button stays touchable.
-	pub size:      f32,
+	pub( crate ) on_press:  Option<Msg>,
+	/// Square hit-target size in logical pixels. An explicit [`Self::size`]
+	/// is clamped to a 20 px floor so the button stays touchable; the `0.0`
+	/// default follows the process [`crate::WidgetScaling`] mode.
+	pub( crate ) size:      f32,
 	/// Optional stable identifier for focus management.
-	pub id:        Option<WidgetId>,
+	pub( crate ) id:        Option<WidgetId>,
 	/// Whether this button takes part in the Tab / Shift+Tab cycle. Defaults
 	/// to `false` to match desktop convention — title-bar chrome on macOS,
 	/// GNOME and Windows is click/touch-only and never steals keyboard focus
 	/// from window content. Opt in with [`Self::focusable`] for shells where
 	/// keyboard reachability of decorations matters (accessibility, no-mouse
 	/// kiosks). Pointer / touch hit testing is unaffected by this flag.
-	pub focusable: bool,
+	pub( crate ) focusable: bool,
 }
 
 impl<Msg: Clone> WindowButton<Msg>
@@ -67,7 +68,7 @@ impl<Msg: Clone> WindowButton<Msg>
 		{
 			kind,
 			on_press:  None,
-			size:      theme::SIZE,
+			size:      0.0,
 			id:        None,
 			focusable: false,
 		}
@@ -112,9 +113,10 @@ impl<Msg: Clone> WindowButton<Msg>
 		self
 	}
 
-	pub fn preferred_size( &self, max_width: f32, _canvas: &Canvas ) -> ( f32, f32 )
+	pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> ( f32, f32 )
 	{
-		let s = self.size.min( max_width );
+		let resolved = if self.size > 0.0 { self.size } else { canvas.geom_px( theme::SIZE ) };
+		let s = resolved.min( max_width );
 		( s, s )
 	}
 

src/widget/window_button/tests.rs

@@ -5,11 +5,13 @@ use super::*;
 use crate::render::Canvas;
 
 #[ test ]
-fn default_size_is_decoration_sized()
+fn default_size_follows_widget_scaling()
 {
-	let canvas = Canvas::new( 100, 100 );
+	let _g = crate::TEST_GLOBALS_LOCK.lock().unwrap_or_else( |e| e.into_inner() );
+	let canvas = Canvas::new( 412, 412 );
 	let b = window_button::<()>( WindowButtonKind::Close );
-	assert_eq!( b.preferred_size( 100.0, &canvas ), ( theme::SIZE, theme::SIZE ) );
+	let s = canvas.geom_px( theme::SIZE );
+	assert_eq!( b.preferred_size( 1000.0, &canvas ), ( s, s ) );
 }
 
 #[ test ]