straw: infinite-scroll pagination for channel + search

Wire the new strawcore continuation fetchers through UniFFI and add
load-more-on-scroll to the Channel and Search screens — previously both
loaded only page 1 and stopped.

FFI (rust/strawcore): search() now returns Page{items, continuation};
channelInfo carries videos_continuation; new searchContinuation() and
channelVideosContinuation() suspend funs map the core ContinuationPage.

Channel + Search ViewModels: loadMore() fetches the next page, dedups by
url, advances the token, and stops when the token runs out or a page
yields zero net-new items (guards a looping continuation). Result-set
swaps (channel switch / new submit / cache preview) cancel the in-flight
page, and a token fence inside the state update prevents a stale page
being spliced into a replaced list. Screens add a near-end LazyColumn
trigger (rememberLazyListState + derivedStateOf) and a footer spinner.

rust/strawcore/src/search.rs

@@ -4,6 +4,7 @@
 // changes.
 
 use strawcore_core::stream::StreamInfoItem;
+use strawcore_core::youtube::continuation::ContinuationPage;
 use strawcore_core::youtube::linkhandler::search::SearchFilter;
 use strawcore_core::youtube::search_extractor;
 
@@ -26,6 +27,24 @@ pub struct SearchItem {
     pub upload_date_relative: String,
 }
 
+/// A page of results plus the opaque token that fetches the NEXT page.
+/// `continuation == null` means there are no more results — the Kotlin
+/// side stops requesting once it sees a null token. Shared by `search`,
+/// `search_continuation`, and the channel-videos continuation.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct Page {
+    pub items: Vec<SearchItem>,
+    pub continuation: Option<String>,
+}
+
+/// Map a core ContinuationPage (channel or search) onto the FFI Page.
+pub(crate) fn page_from_core(page: ContinuationPage) -> Page {
+    Page {
+        items: page.items.into_iter().map(from_core).collect(),
+        continuation: page.continuation,
+    }
+}
+
 pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem {
     let uploader_url = if item.uploader_url.is_empty() {
         None
@@ -53,7 +72,7 @@ pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem {
 }
 
 #[uniffi::export(async_runtime = "tokio")]
-pub async fn search(query: String) -> Result<Vec<SearchItem>, StrawcoreError> {
+pub async fn search(query: String) -> Result<Page, StrawcoreError> {
     // Don't log the query itself — searches are PII (sometimes
     // names, sometimes embarrassing) and android_logger emits at
     // info-level in release builds, which means they'd ride the
@@ -72,5 +91,25 @@ pub async fn search(query: String) -> Result<Vec<SearchItem>, StrawcoreError> {
     .map_err(|e| StrawcoreError::Extractor {
         msg: format!("join: {e}"),
     })??;
-    Ok(result.videos.into_iter().map(from_core).collect())
+    // Page 1 carries the first continuation token (None once YT stops
+    // handing them out). The Kotlin SearchViewModel passes it back to
+    // `search_continuation` on scroll.
+    Ok(Page {
+        items: result.videos.into_iter().map(from_core).collect(),
+        continuation: result.continuation_token,
+    })
+}
+
+/// Fetch the next page of search results from a continuation token
+/// returned by a prior `search` / `search_continuation` Page.
+#[uniffi::export(async_runtime = "tokio")]
+pub async fn search_continuation(token: String) -> Result<Page, StrawcoreError> {
+    log::info!("strawcore::search_continuation token_len={}", token.len());
+    crate::runtime::ensure_initialized();
+    let page = tokio::task::spawn_blocking(move || search_extractor::search_continuation(&token))
+        .await
+        .map_err(|e| StrawcoreError::Extractor {
+            msg: format!("join: {e}"),
+        })??;
+    Ok(page_from_core(page))
 }