feat: ajouter le keepalive SSH et la reconnexion automatique

- Session gagne keepalive_enabled/interval/count_max (actif par defaut : ne
  fait qu'envoyer des paquets de maintien, sans risque pour les sessions
  existantes) et reconnect_enabled/initial_delay/max_attempts (desactive par
  defaut : change reellement le comportement en cas de coupure, donc a
  activer explicitement).

- SSHConnection._keepalive_loop() : thread dedie qui envoie
  "keepalive@openssh.com" (comme OpenSSH) avec accuse de reception toutes les
  `keepalive_interval` secondes. Un serveur conforme repond immediatement
  (meme en echec), ce qui confirme que le transport est vivant. Apres
  `keepalive_count_max` echecs consecutifs (aucune reponse), le canal est
  ferme pour que la boucle de lecture principale s'en apercoive et emette
  `disconnected` avec une raison explicite.

- SessionTabWidget programme une reconnexion (QTimer, jamais de blocage de
  l'interface) quand la session l'autorise et que la deconnexion n'est pas
  volontaire (_closing) : delai en backoff exponentiel plafonne
  (app.services.reconnect.compute_backoff_delay), compte a rebours affiche
  ("Connexion perdue (...). Reconnexion dans Ns... (Tentative X/Y)"), abandon
  au-dela de reconnect_max_attempts (0 = illimite), compteur remis a zero des
  qu'une connexion reussit. Ne se declenche jamais sur une simple erreur
  d'authentification (seul un `disconnected` apres connexion reussie
  declenche une reconnexion, pas un `error` de connexion initiale - sinon un
  mot de passe errone entrainerait des tentatives repetees).

- BaseTerminalTab : les signaux connected/disconnected/error d'une connexion
  sont desormais associes a la generation de connexion en cours au moment ou
  ils sont cables ; un signal parvenant apres qu'une reconnexion (manuelle ou
  automatique) ait deja demarre une nouvelle connexion est ignore. Necessaire
  ici : les signaux Qt entre threads sont mis en file et ne sont livres
  qu'apres le retour de reconnect() a la boucle d'evenements, alors qu'une
  nouvelle connexion est deja en place.

- SessionDialog : sections "Keepalive" et "Reconnexion automatique".

tests/test_keepalive.py (paramiko entierement mocke), test_reconnect_backoff.py
(fonction pure) et test_auto_reconnect.py (SSHConnection.start() neutralisee :
la programmation de la reconnexion ne depend d'aucune connexion reseau reelle).

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

app/dialogs/session_dialog.py

@@ -80,6 +80,8 @@ class SessionDialog(QDialog):
 
         layout.addLayout(form)
         layout.addWidget(self._build_bastion_group())
+        layout.addWidget(self._build_keepalive_group())
+        layout.addWidget(self._build_reconnect_group())
 
         self.save_check = QCheckBox("Enregistrer dans mes sessions (optionnel)")
         if self.quick_mode:
@@ -260,6 +262,59 @@ class SessionDialog(QDialog):
             bastion.key_path = self.bastion_key_combo.currentData() or ""
         return bastion
 
+    # ---------- Keepalive ----------
+    def _build_keepalive_group(self) -> QGroupBox:
+        session = self.session
+        group = QGroupBox("Keepalive")
+        form = QFormLayout(group)
+
+        self.keepalive_check = QCheckBox("Active")
+        self.keepalive_check.setChecked(session.keepalive_enabled)
+        self.keepalive_interval_spin = QSpinBox()
+        self.keepalive_interval_spin.setRange(5, 3600)
+        self.keepalive_interval_spin.setSuffix(" s")
+        self.keepalive_interval_spin.setValue(session.keepalive_interval or 30)
+        self.keepalive_count_spin = QSpinBox()
+        self.keepalive_count_spin.setRange(1, 20)
+        self.keepalive_count_spin.setValue(session.keepalive_count_max or 3)
+
+        form.addRow(self.keepalive_check)
+        form.addRow("Intervalle :", self.keepalive_interval_spin)
+        form.addRow("Nombre d'echecs avant abandon :", self.keepalive_count_spin)
+
+        self.keepalive_check.toggled.connect(self.keepalive_interval_spin.setEnabled)
+        self.keepalive_check.toggled.connect(self.keepalive_count_spin.setEnabled)
+        self.keepalive_interval_spin.setEnabled(session.keepalive_enabled)
+        self.keepalive_count_spin.setEnabled(session.keepalive_enabled)
+        return group
+
+    # ---------- Reconnexion automatique ----------
+    def _build_reconnect_group(self) -> QGroupBox:
+        session = self.session
+        group = QGroupBox("Reconnexion automatique")
+        form = QFormLayout(group)
+
+        self.reconnect_check = QCheckBox("Reconnexion automatique")
+        self.reconnect_check.setChecked(session.reconnect_enabled)
+        self.reconnect_delay_spin = QSpinBox()
+        self.reconnect_delay_spin.setRange(1, 300)
+        self.reconnect_delay_spin.setSuffix(" s")
+        self.reconnect_delay_spin.setValue(session.reconnect_initial_delay or 5)
+        self.reconnect_attempts_spin = QSpinBox()
+        self.reconnect_attempts_spin.setRange(0, 1000)
+        self.reconnect_attempts_spin.setSpecialValueText("Illimite")
+        self.reconnect_attempts_spin.setValue(session.reconnect_max_attempts)
+
+        form.addRow(self.reconnect_check)
+        form.addRow("Delai initial :", self.reconnect_delay_spin)
+        form.addRow("Tentatives maximum (0 = illimite) :", self.reconnect_attempts_spin)
+
+        self.reconnect_check.toggled.connect(self.reconnect_delay_spin.setEnabled)
+        self.reconnect_check.toggled.connect(self.reconnect_attempts_spin.setEnabled)
+        self.reconnect_delay_spin.setEnabled(session.reconnect_enabled)
+        self.reconnect_attempts_spin.setEnabled(session.reconnect_enabled)
+        return group
+
     def should_save(self) -> bool:
         """En connexion rapide, indique si la session doit aussi etre enregistree."""
         return self.save_check.isChecked() if self.quick_mode else True
@@ -305,6 +360,12 @@ class SessionDialog(QDialog):
         self.session.key_path = self.key_combo.currentData() or ""
         self.session.notes = self.notes_edit.toPlainText()
         self.session.bastion = self._result_bastion()
+        self.session.keepalive_enabled = self.keepalive_check.isChecked()
+        self.session.keepalive_interval = self.keepalive_interval_spin.value()
+        self.session.keepalive_count_max = self.keepalive_count_spin.value()
+        self.session.reconnect_enabled = self.reconnect_check.isChecked()
+        self.session.reconnect_initial_delay = self.reconnect_delay_spin.value()
+        self.session.reconnect_max_attempts = self.reconnect_attempts_spin.value()
         self.accept()
 
     def result_session(self) -> Session: