Rework library sync around a JSON document; add card filters

Sync

The previous design put the merge inside SQL: timestamp-stamping triggers,
a tombstone table, per-device SQLite snapshots, a device id in the database,
and row merges written as correlated-subquery UPDATEs. All of that schema
was inherited by desktop, and the merge was very hard to verify.

Replace it with a single JSON document plus a three-way merge in plain Rust.
Storing the last-read remote document as the merge base makes "who changed
what" and "what was deleted" derivable, which removes the tombstone table,
the updated_at columns and all eight triggers. It also makes a single shared
file safe: if a publish is lost the remote is unchanged, so the next merge
re-detects the local edits and republishes rather than reading their absence
as a deletion. That removes the need for per-device files and for device
identity entirely. Schema impact drops to one column, decks.uuid.

Conflicts resolve to "theirs", which is required for convergence rather than
chosen for taste — preferring ours has each device re-asserting its own value
forever. Every such choice is reported to the user.

SQLite becomes invisible: the working copy lives in the app data dir and the
user only ever names a .json file. There is always a document, defaulting to
private storage, so edits are never stranded with nowhere to be saved.
Pointing at a file that doesn't exist yet moves the current library there;
pointing at one that does adopts it. A converter brings a pre-document
library.db across.

Android reaches the folder through the Storage Access Framework rather than
MANAGE_EXTERNAL_STORAGE, so no storage permission is declared at all.

Filters

Track card origin in reference.db: Universes Beyond, digital-only and
Un-set cards, plus numeric power/toughness. Each origin flag is derived as
"every printing", not "any printing" — ordinary cards get reprinted into
those sets, and Lightning Bolt appearing in Marvel Commander must not hide
it. Non-numeric power ("*", "1+*") stays NULL so it drops out of range
filters instead of being compared as zero.

Also wire up filters over data already present: price range, format legality
(restricted counts as legal) and "can be a commander". All of these degrade
silently against an older reference.db rather than failing every query.

The shared criteria live in one component used by both filter panels, as a
compact row of icon toggles.

Card Search gains the Library tab's bulk selection: checkboxes in both views,
select-all, and a bulk add-to-deck with a single undo for the whole batch.

src-tauri/src/commands.rs

@@ -42,7 +42,11 @@ fn status_of(s: &AppState) -> Status {
         .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
         .map(|d| d.as_secs() as i64);
     Status {
-        library_path: s.library_path.display().to_string(),
+        // Where the library document lives, not the internal working database —
+        // that one is an implementation detail the user never sees. Always
+        // populated: with nothing chosen it's the default in private storage,
+        // so the path bar never goes blank.
+        library_path: s.effective_document_path().display().to_string(),
         reference_path: s.reference_path.display().to_string(),
         reference_ready: s.catalog.is_some(),
         card_count: s.index.as_ref().map(|i| i.len()).unwrap_or(0),
@@ -66,18 +70,6 @@ pub fn get_status(db: Db) -> Res<Status> {
     Ok(status)
 }
 
-#[tauri::command]
-pub fn set_library_path(db: Db, path: String) -> Res<Status> {
-    let mut s = db.lock().unwrap();
-    s.set_library_path(PathBuf::from(path));
-    // Best-effort reopen: the chosen path must stick (and be reported back)
-    // even if the reference db can't currently be attached (e.g. stale
-    // schema pending an "Update card data" run) — that's a separate concern
-    // from which library file is open.
-    let _ = s.reopen();
-    Ok(status_of(&s))
-}
-
 /// Download Scryfall bulk data and (re)build reference.db, then reopen.
 /// Runs on a blocking thread so the UI stays responsive and progress events flow.
 #[tauri::command]