ltk: subsurface slides over overlays, axis-locked swipes, physical-space layout, touch reset on resume

Subsurfaces can now be parented to an overlay surface, not just the main surface. `SubsurfaceSpec` gains `parent: SubsurfaceParent { Main, Overlay(id) }` so a sliding panel can ride above app windows the way an overlay panel does, and an optional `gpu: bool` so content that uses the `surface-panel` backdrop-filter glass (a GLES-only pass) keeps it while sliding instead of dropping to the software rasteriser. `reconcile_subsurfaces` resolves each spec's parent independently — skipping an `Overlay` parent that is absent, unconfigured, or zero-sized — tracks the rastered size on the slot, and commits each touched parent once per frame. The ~14 GLES shader programs are compiled once into a shared `AppData::subsurface_gles_canvas` reused across every subsurface, so a lazily re-created sliding panel never recompiles them (hundreds of ms on a mobile GPU).
Vertical and horizontal swipes are now mutually exclusive: a gesture locks onto its dominant axis within the first 8 px of travel (new `SwipeAxis`) and ignores the perpendicular axis for the rest of the gesture, so a vertical swipe that drifts sideways no longer also drives the pager (and vice-versa). The upward swipe progress is no longer clamped at 1.0 — follow-the-finger panels can keep tracking the finger past the commit threshold — and a release below threshold delivers a final `progress = 0.0` cancellation pulse. A vertical swipe also no longer re-rasters the full-screen main surface on every motion event: only the overlays it drives are refreshed, while the horizontal pager (which does move the main surface) still redraws it. Re-rastering the main on every frame of a vertical drag was wasted work that stalled the loop and made the gesture feel laggy to start on a slow GPU.
Layout-affecting `Length` values (widths, paddings, gaps, widget sizes, including `Vw` / `Vh`) now resolve against the physical viewport via the new `Canvas::viewport_layout()` — the space the layout tree is actually computed in — so a `Vw(100)` fills the surface on a HiDPI (scale 2) output instead of covering half of it. Font sizes are unchanged: they still resolve against the logical viewport and are scaled at raster time. Switched column, row, spacer, wrap_grid, container, image, and vslider over to it; `img_widget` and `vslider` now document `Length::vw` / `vh` sizing and the showcase example demonstrates a viewport-relative image.
Touch gesture state is reset when the touch capability is added or removed — suspend / resume on devices that power the touchscreen down. A yanked capability never delivers the pending `up` / `cancel`, so the shared `reset_touch_state()` (also used by the `wl_touch.cancel` handler) drops the stranded `primary_touch_id` / slot state across the main surface and every overlay, keeping the first post-resume gesture clean. Also drops an accidental duplicate `on_scale_changed` call from the scale-change handler.

src/widget/image/mod.rs

@@ -16,10 +16,13 @@ use crate::render::Canvas;
 ///
 /// ```rust,no_run
 /// # use std::sync::Arc;
-/// # use ltk::{ img_widget, Element };
+/// # use ltk::{ img_widget, Element, Length };
 /// # #[ derive( Clone ) ] enum Msg {}
 /// # fn _ex( rgba_bytes: Arc<Vec<u8>>, width: u32, height: u32 ) -> Element<Msg> {
+/// // Display at 40 % of the viewport width by 20 % of its height instead of
+/// // the source's intrinsic pixel size — scales across screens with no tweaks.
 /// img_widget( rgba_bytes, width, height )
+///     .size( Length::vw( 40.0 ), Length::vh( 20.0 ) )
 ///     .opacity( 0.8 )
 /// .into()
 /// # }
@@ -34,7 +37,7 @@ pub struct Image
 	pub height:  u32,
 	/// When `true` the image scales to fill the available width (cover mode).
 	pub cover:   bool,
-	/// Optional explicit display size in logical units.
+	/// Optional explicit display size (Length values, resolved at layout time).
 	pub display_size: Option<( Length, Length )>,
 	/// Opacity multiplier in `[0.0, 1.0]`. Default: `1.0`.
 	pub opacity: f32,
@@ -66,7 +69,8 @@ impl Image
 		self
 	}
 
-	/// Set an explicit display size in logical units.
+	/// Set an explicit display size. Accepts logical `f32` pixels or any
+	/// [`Length`] variant (e.g. `Length::vw(13.0)` for 13 % of viewport width).
 	pub fn size( mut self, width: impl Into<Length>, height: impl Into<Length> ) -> Self
 	{
 		self.display_size = Some( ( width.into(), height.into() ) );
@@ -81,15 +85,16 @@ impl Image
 	}
 
 	/// Return the preferred `(width, height)` given available `max_width`.
+	/// `canvas` is used to resolve viewport-relative [`Length`] values.
 	pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> (f32, f32)
 	{
-		if let Some( ( width, height ) ) = self.display_size
+		if let Some( ( w, h ) ) = &self.display_size
 		{
-			let viewport = canvas.viewport_logical();
-			return (
-				width.resolve( viewport, Length::EM_BASE_DEFAULT ).max( 0.0 ),
-				height.resolve( viewport, Length::EM_BASE_DEFAULT ).max( 0.0 ),
-			);
+			let vp  = canvas.viewport_layout();
+			let em  = Length::EM_BASE_DEFAULT;
+			let rw  = w.resolve( vp, em ).max( 0.0 );
+			let rh  = h.resolve( vp, em ).max( 0.0 );
+			return ( rw, rh );
 		}
 		if self.cover
 		{