ltk: ext-session-lock-v1 client surface mode, plus a read-only mode for text fields

Add a third Wayland surface type to the runtime so an ltk `App` can be a screen locker, alongside the existing xdg-shell window and wlr-layer-shell surfaces. A new `ShellMode::SessionLock` makes `run()` bind `ext_session_lock_manager_v1` and request the lock at startup; the lock surface itself is created in the new `SessionLockHandler::locked` callback (one surface on the first advertised output) and replaces the `SurfaceKind::PendingLock` placeholder the main surface holds until the compositor grants the lock. The `configure` event routes through the same `on_configure` path as layer and xdg surfaces, so sizing and rendering are unchanged, and `finished` (the compositor denied or ended the lock) tears the loop down. The whole thing is additive and opt-in: the `Window` and `Layer` paths are untouched and nothing enters lock mode unless an `App` returns `ShellMode::SessionLock`, so existing apps are unaffected — the only non-additive edits are the two exhaustive `match`es on `SurfaceKind` (`wl_surface` / `try_wl_surface`), which gain arms for the two new variants.
Doing the locker as a first-class surface rather than compositing a static texture into an offscreen `UiSurface` is the whole point: the compositor gives the lock surface keyboard focus, so ltk's existing text-input, editing, focus and IME machinery works inside the lock exactly as on any other surface — cursor, click-to-focus, Tab, character input. A locker built on top of this is just a normal interactive ltk app that happens to be presented on the lock layer, with no special input plumbing on the compositor or the app side.
`App::requested_exit()` is the new way an app asks the runtime to tear the surface down and leave the loop; it is polled after every batch of `update`s. It exists because of the one hard invariant of `ext-session-lock-v1`: a locker that disconnects without sending `unlock` leaves the compositor's outputs blanked forever — that is the protocol's deliberate anti-bypass guarantee. So when `requested_exit()` returns true and the surface is a session lock, the loop calls `session_lock.unlock()` and round-trips the connection before setting `exit_requested`, lifting the lock cleanly; for a `Window` or `Layer` surface there is no lock and it simply exits. The consequence for lock apps is that they must stop calling `process::exit` from the lock path and instead flip a flag they return from `requested_exit()`.
`text_edit` gains a `read_only( bool )` builder. A read-only field still renders its box and value in the normal field style but takes no keyboard focus and accepts no input: `Element::is_focusable` and `Element::is_text_input` now return false for a read-only `TextEdit`, which keeps it out of the Tab cycle, off the keyboard-edit path, and stops the cursor from ever being drawn on it. The flag is carried through `map_msg` so it survives `Element::map`. This is for presenting a known, non-editable value in the same visual idiom as the editable fields beside it — for example the already-known user shown on a session lock, where letting that field take focus or blink a cursor would be wrong.
The `shell_mode()` doc comment and the README now list the `SessionLock` surface type and point at `requested_exit()` for the unlock. Two warnings are cleared along the way: the runtime no longer stores the `SessionLockState` after requesting the lock — it has no `Drop`, so the manager object outlives the dropped handle inside the connection and the lock lifecycle runs entirely off the returned `SessionLock`, which removes a never-read field — and a pre-existing rustdoc `private_intra_doc_links` warning in `list_item` (a public doc comment linking to the private `theme::ICON_SIZE`) is downgraded to plain code formatting.

src/event_loop/handlers.rs

@@ -7,7 +7,7 @@ use smithay_client_toolkit::
 	delegate_compositor, delegate_foreign_toplevel_list, delegate_layer,
 	delegate_output, delegate_registry, delegate_seat, delegate_keyboard,
 	delegate_pointer, delegate_touch, delegate_shm, delegate_xdg_popup,
-	delegate_xdg_shell, delegate_xdg_window,
+	delegate_xdg_shell, delegate_xdg_window, delegate_session_lock,
 	foreign_toplevel_list::{ ForeignToplevelList, ForeignToplevelListHandler },
 	output::{ OutputHandler, OutputState },
 	registry::{ ProvidesRegistryState, RegistryState },
@@ -22,6 +22,7 @@ use smithay_client_toolkit::
 		xdg::window::{ Window, WindowConfigure, WindowHandler },
 	},
 	shm::{ Shm, ShmHandler },
+	session_lock::{ SessionLock, SessionLockHandler, SessionLockSurface, SessionLockSurfaceConfigure },
 };
 use smithay_client_toolkit::reexports::protocols::ext::foreign_toplevel_list::v1::client::ext_foreign_toplevel_handle_v1::ExtForeignToplevelHandleV1;
 use smithay_client_toolkit::reexports::client::
@@ -396,6 +397,39 @@ impl<A: App> PopupHandler for AppData<A>
 
 // --- Delegate macros ---
 
+impl<A: App> SessionLockHandler for AppData<A>
+{
+	fn locked( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, session_lock: SessionLock )
+	{
+		if let Some( output ) = self.output_state.outputs().next()
+		{
+			let surface      = self.compositor_state.create_surface( qh );
+			let lock_surface = session_lock.create_lock_surface( surface, &output, qh );
+			self.main.surface = super::SurfaceKind::Lock( lock_surface );
+		}
+		self.session_lock = Some( session_lock );
+	}
+
+	fn finished( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _session_lock: SessionLock )
+	{
+		// Compositor refused the lock or ended it; nothing left to show.
+		self.exit_requested = true;
+	}
+
+	fn configure(
+		&mut self,
+		_conn:     &Connection,
+		_qh:       &QueueHandle<Self>,
+		_surface:  SessionLockSurface,
+		configure: SessionLockSurfaceConfigure,
+		_serial:   u32,
+	)
+	{
+		let ( w, h ) = configure.new_size;
+		self.on_configure( w.max( 1 ), h.max( 1 ) );
+	}
+}
+
 delegate_compositor!(  @<A: App> AppData<A> );
 delegate_output!(      @<A: App> AppData<A> );
 delegate_shm!(         @<A: App> AppData<A> );
@@ -404,6 +438,7 @@ delegate_keyboard!(    @<A: App> AppData<A> );
 delegate_pointer!(     @<A: App> AppData<A> );
 delegate_touch!(       @<A: App> AppData<A> );
 delegate_layer!(       @<A: App> AppData<A> );
+delegate_session_lock!( @<A: App> AppData<A> );
 delegate_xdg_shell!(   @<A: App> AppData<A> );
 delegate_xdg_window!(  @<A: App> AppData<A> );
 delegate_xdg_popup!(   @<A: App> AppData<A> );