refactor: split into idx-core library and idx-cli binary workspace

Phase 2 of docs/DESIGN.md, no behavior change:

- crates/idx-core (library): api, analysis, cache, config file handling
  and provider selection, curl_impersonate, error, ownership, runtime,
  plus the shared test fixtures. clap derives are behind an optional
  `clap` feature so the library does not require clap.
- crates/idx-cli (binary `idx`): cli/, output/, and IdxConfig (output
  format and color resolution). Package and binary names are unchanged.
- config.rs is split: file read/write and validation move to core; a
  CLI test keeps core's OUTPUT_VALUES in sync with OutputSetting.
- ownership::db::open_db/db_path drop their unused IdxConfig argument.
- One workspace version; shared dependency versions; no third-party
  version changes in Cargo.lock. LICENSE is symlinked into each crate.
- flake: workspace version, new source paths, and a per-crate package
  check (idx-cli is built from its tarball against packaged idx-core,
  since idx-core is not on crates.io yet). CI cache key, release path
  filter, and the golden whitespace-hook exclusion follow the new layout.

Parity: all 143 golden outputs match byte for byte without
regeneration; 157 core + 17 CLI unit tests (173 before plus the new
OUTPUT_VALUES sync test), 62 CLI tests pass. Live A/B against main:
16/16 stocks cases identical; ownership discover got IDX 403 on both
(exit 4 vs 1 is the phase 1 exit-code change).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/idx-core/src/ownership/search.rs

@@ -0,0 +1,111 @@
+use rusqlite::{Connection, params};
+
+use crate::error::IdxError;
+use crate::ownership::types::Entity;
+
+pub fn fts_search(conn: &Connection, query: &str, limit: usize) -> Result<Vec<Entity>, IdxError> {
+    let q = query.trim();
+    if q.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let limit_i64 =
+        i64::try_from(limit).map_err(|e| IdxError::DatabaseError(format!("invalid limit: {e}")))?;
+
+    // Ensure entity_fts has content. For external-content FTS table, populate manually.
+    let fts_count: i64 = conn
+        .query_row("SELECT COUNT(*) FROM entity_fts", [], |row| row.get(0))
+        .unwrap_or(0);
+
+    if fts_count == 0 {
+        let _ = rebuild_fts(conn);
+    }
+
+    if let Ok(rows) = fts_query(conn, q, limit_i64)
+        && !rows.is_empty()
+    {
+        return Ok(rows);
+    }
+
+    like_query(conn, q, limit_i64)
+}
+
+fn fts_query(conn: &Connection, query: &str, limit: i64) -> Result<Vec<Entity>, IdxError> {
+    let mut stmt = conn
+        .prepare(
+            "SELECT e.id, e.canonical_name, e.entity_type, e.country
+             FROM entity_fts f
+             JOIN entities e ON e.id = f.rowid
+             WHERE entity_fts MATCH ?1
+             ORDER BY rank
+             LIMIT ?2",
+        )
+        .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    let rows = stmt
+        .query_map(params![query, limit], |row| {
+            Ok(Entity {
+                id: row.get(0)?,
+                canonical_name: row.get(1)?,
+                entity_type: row.get(2)?,
+                country: row.get(3)?,
+            })
+        })
+        .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    let mut out = Vec::new();
+    for row in rows {
+        out.push(row.map_err(|e| IdxError::DatabaseError(e.to_string()))?);
+    }
+    Ok(out)
+}
+
+fn like_query(conn: &Connection, query: &str, limit: i64) -> Result<Vec<Entity>, IdxError> {
+    let mut stmt = conn
+        .prepare(
+            "SELECT id, canonical_name, entity_type, country
+             FROM entities
+             WHERE canonical_name LIKE ?1 COLLATE NOCASE
+             ORDER BY canonical_name ASC
+             LIMIT ?2",
+        )
+        .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    let like = format!("%{query}%");
+    let rows = stmt
+        .query_map(params![like, limit], |row| {
+            Ok(Entity {
+                id: row.get(0)?,
+                canonical_name: row.get(1)?,
+                entity_type: row.get(2)?,
+                country: row.get(3)?,
+            })
+        })
+        .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    let mut out = Vec::new();
+    for row in rows {
+        out.push(row.map_err(|e| IdxError::DatabaseError(e.to_string()))?);
+    }
+    Ok(out)
+}
+
+pub fn rebuild_fts(conn: &Connection) -> Result<(), IdxError> {
+    conn.execute("DELETE FROM entity_fts", [])
+        .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    conn.execute(
+        "INSERT INTO entity_fts(rowid, canonical_name, aliases)
+         SELECT e.id, e.canonical_name, COALESCE(a.aliases, '')
+         FROM entities e
+         LEFT JOIN (
+             SELECT entity_id, GROUP_CONCAT(raw_name, ' ') AS aliases
+             FROM entity_aliases
+             GROUP BY entity_id
+         ) a ON a.entity_id = e.id",
+        [],
+    )
+    .map_err(|e| IdxError::DatabaseError(e.to_string()))?;
+
+    Ok(())
+}