refactor: tighten dead-code allows post-integration

Module-wide #![allow(dead_code)] on change_tracker and
structure_tracker was a rollout-time concession ("many items public
for the upcoming UI integration"). Integration is done; replace the
broad allows with targeted ones that document the actual reason
each survivor stays around.

- change_tracker: drop module #![allow], drop function-level allows
  on open_tab / close_tab / any_pending_globally / pending_tabs
  (all now used in production), keep test-only `new` / `can_undo` /
  `can_redo` behind #[cfg(test)] so they compile out of release.
- structure_tracker: same pattern; RenameColumn / ReorderColumn ops
  remain because materialize knows them but the UI doesn't yet
  emit, so each carries a documented #[allow(dead_code)] with a
  comment instead of the module-wide silence.
- structure_tab: drop the placeholder #[allow(dead_code)] on
  StructureTabOutput — every variant has an emit site now.
- error_text: build_sql_message is test-only, gate via #[cfg(test)]
  + matching #[cfg(test)] use of BuildSqlError. driver_message is
  used in three production sites; drop the allow.
- app/mod TableTabSlot: drop struct-level allow; every field is
  read.
- AppMsg: drop the enum-level allow that hid every variant; keep
  two narrow item-level allows on UndoActiveStructureTab /
  RedoActiveStructureTab (handlers exist, no emit-site yet) so
  any future stale variant surfaces as a real warning.

Net effect: the codebase compiles with `cargo build --workspace`
clean of warnings, AND `cargo clippy -D warnings` passes. Future
dead code now surfaces immediately instead of being absorbed by
broad allows.

Author: datlechin

linux/crates/app/src/services/change_tracker.rs

@@ -25,11 +25,6 @@
 //! Tests should construct a fresh `ChangeTrackerRegistry::new()` to
 //! avoid contaminating each other through the thread-local global.
 
-// Many items are public for the upcoming UI integration but unused
-// at this point of the rollout — silence dead-code warnings module-
-// wide rather than annotating each item.
-#![allow(dead_code)]
-
 use std::cell::RefCell;
 use std::collections::{HashMap, VecDeque};
 
@@ -204,6 +199,7 @@ pub struct TabChangeTracker {
 }
 
 impl TabChangeTracker {
+    #[cfg(test)]
     pub fn new() -> Self {
         Self::default()
     }
@@ -416,10 +412,12 @@ impl TabChangeTracker {
         Some(op)
     }
 
+    #[cfg(test)]
     pub fn can_undo(&self) -> bool {
         !self.undo.is_empty()
     }
 
+    #[cfg(test)]
     pub fn can_redo(&self) -> bool {
         !self.redo.is_empty()
     }
@@ -753,26 +751,22 @@ where
 }
 
 /// Open a tracker for a tab. Idempotent.
-#[allow(dead_code)]
 pub fn open_tab(tab_id: Uuid) {
     REGISTRY.with(|reg| reg.borrow_mut().open_tab(tab_id));
 }
 
 /// Drop a tab's tracker. Called when the BrowseTab is closed.
-#[allow(dead_code)]
 pub fn close_tab(tab_id: Uuid) {
     REGISTRY.with(|reg| reg.borrow_mut().close_tab(tab_id));
 }
 
 /// True if any open tab has pending changes — used by the app-level
 /// quit guard to decide whether to show the "Unsaved changes" dialog.
-#[allow(dead_code)]
 pub fn any_pending_globally() -> bool {
     REGISTRY.with(|reg| reg.borrow().any_pending())
 }
 
 /// Tabs with pending changes — ordered arbitrary (HashMap iteration).
-#[allow(dead_code)]
 pub fn pending_tabs() -> Vec<Uuid> {
     REGISTRY.with(|reg| reg.borrow().pending_tabs())
 }

linux/crates/app/src/services/structure_tracker.rs

@@ -14,8 +14,6 @@
 //! `StructureTrackerRegistry::new()` instances to avoid contaminating
 //! each other through the thread-local global.
 
-#![allow(dead_code)]
-
 use std::cell::RefCell;
 use std::collections::{HashMap, VecDeque};
 
@@ -60,6 +58,12 @@ pub enum StructureOp {
         table: String,
         column_name: String,
     },
+    /// Renames a column inline. The Structure tab UI doesn't yet
+    /// expose this op as a dedicated affordance — column-name edits
+    /// today round-trip through Drop+Add via the AlterColumn path —
+    /// but `materialize` knows how to emit the SQL when a future UI
+    /// flow pushes it.
+    #[allow(dead_code)]
     RenameColumn {
         schema: Option<String>,
         table: String,
@@ -75,7 +79,11 @@ pub enum StructureOp {
         table: String,
         column: DraftColumn,
     },
-    /// MySQL-only. `after = None` means FIRST.
+    /// MySQL-only column reorder via `MODIFY COLUMN ... AFTER`.
+    /// `after = None` means `FIRST`. Drag-reorder UI not yet wired —
+    /// the materialize path is in place so adding the gesture later
+    /// is one UI commit.
+    #[allow(dead_code)]
     ReorderColumn {
         schema: Option<String>,
         table: String,
@@ -134,6 +142,7 @@ pub struct StructureChangeTracker {
 }
 
 impl StructureChangeTracker {
+    #[cfg(test)]
     pub fn new() -> Self {
         Self::default()
     }
@@ -213,10 +222,12 @@ impl StructureChangeTracker {
         Some(forward)
     }
 
+    #[cfg(test)]
     pub fn can_undo(&self) -> bool {
         !self.undo.is_empty()
     }
 
+    #[cfg(test)]
     pub fn can_redo(&self) -> bool {
         !self.redo.is_empty()
     }

linux/crates/app/src/ui/app/mod.rs

@@ -151,7 +151,6 @@ pub enum TableMode {
 /// parallel inside an `AdwViewStack`. Switching `mode` flips the
 /// stack's visible child without destroying state on the inactive
 /// side; pending-change trackers, pagination, sort, search remain.
-#[allow(dead_code)]
 pub struct TableTabSlot {
     pub id: Uuid,
     pub page: adw::TabPage,
@@ -251,11 +250,6 @@ pub(super) fn read_workspace_tab_id(page: &adw::TabPage) -> Option<Uuid> {
     unsafe { page.qdata::<Uuid>(workspace_tab_id_quark()).map(|p| *p.as_ref()) }
 }
 
-// `UndoActiveStructureTab` / `RedoActiveStructureTab` are the only
-// variants without a current emit site (Structure tab Ctrl+Z/Y will
-// fire them in a follow-up commit alongside the full UI). Carrying
-// the keep-alive on the enum is cheaper than annotating each variant.
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum AppMsg {
     OpenConnect,
@@ -475,9 +469,14 @@ pub enum AppMsg {
     /// the sidebar factory without going through the full Connected
     /// path.
     TablesReloaded(Vec<TableInfo>),
-    /// Ctrl+Z on a Structure tab.
+    /// Ctrl+Z on a Structure tab. The Structure-side Ctrl+Z UI is
+    /// not yet wired; the handler is in place so the keybinding
+    /// can be added in a one-line follow-up.
+    #[allow(dead_code)]
     UndoActiveStructureTab,
-    /// Ctrl+Y on a Structure tab.
+    /// Ctrl+Y on a Structure tab. Same status as
+    /// `UndoActiveStructureTab`.
+    #[allow(dead_code)]
     RedoActiveStructureTab,
 }
 

linux/crates/app/src/ui/error_text.rs

@@ -1,8 +1,8 @@
 use tablepro_core::DriverError;
-
+#[cfg(test)]
 use tablepro_core::sql_dialect::BuildSqlError;
 
-#[allow(dead_code)]
+#[cfg(test)]
 pub fn build_sql_message(error: &BuildSqlError) -> String {
     match error {
         BuildSqlError::NoPrimaryKey => crate::tr!("This table has no primary key. Use the modal Edit dialog instead."),
@@ -15,7 +15,6 @@ pub fn build_sql_message(error: &BuildSqlError) -> String {
     }
 }
 
-#[allow(dead_code)]
 pub fn driver_message(error: &DriverError) -> String {
     match error {
         DriverError::ConnectionRefused => crate::tr!("Could not reach the database. Is it running?"),

linux/crates/app/src/ui/structure_tab.rs

@@ -239,7 +239,6 @@ pub enum ColumnField {
     Default(Option<String>),
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum StructureTabOutput {
     DirtyChanged(bool),