refactor: implement trait-based DI for TdClient and fix stack overflow

Implement complete trait-based dependency injection pattern for TdClient
to enable testing with FakeTdClient mock. Fix critical stack overflow bugs
caused by infinite recursion in trait implementations.

Breaking Changes:
- App is now generic: App<T: TdClientTrait = TdClient>
- All UI and input handlers are generic over TdClientTrait
- TdClient methods now accessed through trait interface

New Files:
- src/tdlib/trait.rs: TdClientTrait definition with 40+ methods
- src/tdlib/client_impl.rs: TdClientTrait impl for TdClient
- tests/helpers/fake_tdclient_impl.rs: TdClientTrait impl for FakeTdClient

Critical Fixes:
- Fix stack overflow in send_message, edit_message, delete_messages
- Fix stack overflow in forward_messages, current_chat_messages
- Fix stack overflow in current_pinned_message
- All methods now call message_manager directly to avoid recursion

Testing:
- FakeTdClient supports configurable auth_state for auth screen tests
- Added pinned message support in FakeTdClient
- All 196+ tests passing (188 tests + 8 benchmarks)

Dependencies:
- Added async-trait = "0.1"

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

src/main.rs

@@ -56,49 +56,12 @@ async fn main() -> Result<(), io::Error> {
 
     // Create app state
     let mut app = App::new(config);
-    let res = run_app(&mut terminal, &mut app).await;
-
-    // Restore terminal
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture)?;
-    terminal.show_cursor()?;
-
-    if let Err(err) = res {
-        println!("Error: {:?}", err);
-    }
-
-    Ok(())
-}
-
-async fn run_app<B: ratatui::backend::Backend>(
-    terminal: &mut Terminal<B>,
-    app: &mut App,
-) -> io::Result<()> {
-    // Флаг для остановки polling задачи
-    let should_stop = Arc::new(AtomicBool::new(false));
-    let should_stop_clone = should_stop.clone();
-
-    // Канал для передачи updates из polling задачи в main loop
-    let (update_tx, mut update_rx) = tokio::sync::mpsc::unbounded_channel::<Update>();
-
-    // Запускаем polling TDLib receive() в отдельной задаче
-    let polling_handle = tokio::spawn(async move {
-        while !should_stop_clone.load(Ordering::Relaxed) {
-            // receive() с таймаутом 0.1 сек чтобы периодически проверять флаг
-            let result = tokio::task::spawn_blocking(|| tdlib_rs::receive()).await;
-            if let Ok(Some((update, _client_id))) = result {
-                if update_tx.send(update).is_err() {
-                    break; // Канал закрыт, выходим
-                }
-            }
-        }
-    });
-
-    // Запускаем инициализацию TDLib в фоне
+    
+    // Запускаем инициализацию TDLib в фоне (только для реального клиента)
     let client_id = app.td_client.client_id();
     let api_id = app.td_client.api_id;
     let api_hash = app.td_client.api_hash.clone();
-
+    
     tokio::spawn(async move {
         let _ = tdlib_rs::functions::set_tdlib_parameters(
             false,                    // use_test_dc
@@ -119,6 +82,44 @@ async fn run_app<B: ratatui::backend::Backend>(
         )
         .await;
     });
+    
+    let res = run_app(&mut terminal, &mut app).await;
+
+    // Restore terminal
+    disable_raw_mode()?;
+    execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture)?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("Error: {:?}", err);
+    }
+
+    Ok(())
+}
+
+async fn run_app<B: ratatui::backend::Backend, T: tdlib::TdClientTrait>(
+    terminal: &mut Terminal<B>,
+    app: &mut App<T>,
+) -> io::Result<()> {
+    // Флаг для остановки polling задачи
+    let should_stop = Arc::new(AtomicBool::new(false));
+    let should_stop_clone = should_stop.clone();
+
+    // Канал для передачи updates из polling задачи в main loop
+    let (update_tx, mut update_rx) = tokio::sync::mpsc::unbounded_channel::<Update>();
+
+    // Запускаем polling TDLib receive() в отдельной задаче
+    let polling_handle = tokio::spawn(async move {
+        while !should_stop_clone.load(Ordering::Relaxed) {
+            // receive() с таймаутом 0.1 сек чтобы периодически проверять флаг
+            let result = tokio::task::spawn_blocking(|| tdlib_rs::receive()).await;
+            if let Ok(Some((update, _client_id))) = result {
+                if update_tx.send(update).is_err() {
+                    break; // Канал закрыт, выходим
+                }
+            }
+        }
+    });
 
     loop {
         // Обрабатываем updates от TDLib из канала (неблокирующе)
@@ -203,7 +204,7 @@ async fn run_app<B: ratatui::backend::Backend>(
 }
 
 /// Возвращает true если состояние изменилось и требуется перерисовка
-async fn update_screen_state(app: &mut App) -> bool {
+async fn update_screen_state<T: tdlib::TdClientTrait>(app: &mut App<T>) -> bool {
     use tokio::time::timeout;
 
     let prev_screen = app.screen.clone();