feat(mobile): Zurück-Geste schließt die Ansicht, zwei Finger zoomen das PDF

Zwei Dinge, die am Telefon fehlten – beide in der installierten App
besonders schmerzhaft, weil es dort keine Adresszeile als Rückweg gibt.

1. Zurück schloss bisher die Anwendung, nicht die Vorschau. Vorschau,
   Office-Editor und die aufgeschobene Seitenleiste kamen im Verlauf des
   Browsers gar nicht vor: Der einzige Eintrag war die Dateiliste. Jetzt
   legt jede bildschirmfüllende Ansicht beim Öffnen einen leeren Eintrag
   an (die Adresse bleibt gleich – eine Vorschau ist kein Ort für ein
   Lesezeichen) und verbraucht ihn beim Schließen wieder, egal ob über
   die Geste, Escape oder den Knopf. Ein Stapel sorgt dafür, dass bei
   übereinanderliegenden Ansichten nur die oberste reagiert.

   Collabora blendet auf kleinen Schirmen seinen eigenen Schließen-Knopf
   aus (closeButtonEnabled && !isSmallScreenDevice) – ohne diesen Weg
   käme man aus einem Dokument am Telefon nur über die Kopfzeile heraus.

2. Die Zusammenziehgeste vergrößerte die ganze Seite statt des PDFs:
   Leiste und Knöpfe wuchsen mit, das Dokument blieb grob. touch-action
   nimmt dem Browser die Geste, ein eigener Zuhörer setzt unsere
   Zoomstufen an ihre Stelle, verankert an der Mitte zwischen den
   Fingern – dieselbe Regel wie bei Strg+Mausrad.

Gemessen in Chromium mit Touch-Emulation, 412x900:
  Vorschau offen -> Verlauf 2->3, Zurück -> Vorschau zu, Anwendung bleibt
  Esc -> Eintrag wieder weg (ein weiteres Zurück verlässt die App)
  Aufziehen 65% -> 125%, Zuziehen -> 50%, visualViewport.scale bleibt 1

Ein Befund aus dieser Messung steckt im Code: Zuerst kam pro Geste nur
eine Stufe, weil sich der Zuhörer bei jeder Zoomänderung neu anmeldete
und der gemerkte Fingerabstand dabei verlorenging. Abstand und Maßstab
liegen deshalb in Referenzen, der Zuhörer meldet sich einmal an.

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

frontend/src/hooks/useBackClose.ts

@@ -0,0 +1,90 @@
+import { useEffect, useRef } from 'react'
+
+/**
+ * Die Zurück-Taste schließt die oberste bildschirmfüllende Ansicht, statt die
+ * Anwendung zu verlassen.
+ *
+ * Auf einem Telefon ist „zurück" die Geste vom Rand, und in der installierten
+ * App ist sie der einzige Weg nach draußen – ohne Adresszeile, ohne Reiter.
+ * Wer ein Bild ansieht und zurückwischt, meint das Bild. Bisher fiel er aus
+ * der Anwendung, weil Vorschau und Editor im Verlauf des Browsers gar nicht
+ * vorkamen: Der einzige Eintrag war die Dateiliste, und der davor war der
+ * Startbildschirm.
+ *
+ * Der Kniff ist ein **leerer Eintrag** im Verlauf, der beim Öffnen entsteht.
+ * Die Adresse bleibt dabei gleich – die Vorschau ist kein Ort, auf den ein
+ * Lesezeichen zeigen soll. Zurück verbraucht diesen Eintrag, wir schließen,
+ * und der Ort darunter ist unverändert derselbe.
+ *
+ * **Der Stapel ist nötig, nicht schön:** Liegt der Office-Editor über der
+ * Vorschau, hören beide auf dieselbe Zurück-Taste. Ohne Rangfolge schlössen
+ * sich beide auf einmal. Deshalb weiß jeder Eintrag, der wievielte er ist,
+ * und nur der oberste reagiert.
+ */
+
+/** Kennungen der offenen Ansichten, unterste zuerst. */
+let stack: number[] = []
+let seq = 0
+
+/** Wir merken uns unseren Eintrag im State des Browsers, um ihn beim
+ *  Zurückkommen wiederzuerkennen. */
+const stateKey = 'aether:overlay'
+
+interface Options {
+  /** Ist die Ansicht offen? Der Eintrag entsteht beim Wechsel auf `true`. */
+  active: boolean
+  /**
+   * Schließen. Gibt die Funktion `false` zurück, bleibt die Ansicht offen –
+   * dann legen wir den Eintrag wieder an, sonst führte die nächste
+   * Zurück-Geste aus der Anwendung heraus. Das ist der Fall „ungespeicherte
+   * Änderungen verwerfen?" mit „Abbrechen".
+   */
+  onClose: () => boolean | void
+}
+
+export function useBackClose({ active, onClose }: Options) {
+  // Über eine Referenz gelesen: Der Aufrufer gibt bei jedem Rendern eine neue
+  // Funktion herein, und der Eintrag darf davon nicht neu entstehen.
+  const close = useRef(onClose)
+  close.current = onClose
+
+  useEffect(() => {
+    if (!active) return
+
+    const id = ++seq
+    stack.push(id)
+    // Den bisherigen State mitnehmen: Darin steckt die Ansicht der Anwendung
+    // (siehe useNavHistory). Ginge er verloren, stünde man nach dem
+    // Schließen in der Wurzel statt im Ordner.
+    window.history.pushState({ ...window.history.state, [stateKey]: id }, '')
+
+    function push() {
+      window.history.pushState({ ...window.history.state, [stateKey]: id }, '')
+    }
+
+    function onPop() {
+      // Nur der oberste reagiert. Ein tiefer liegender Eintrag hat seinen
+      // eigenen Zurück-Schritt noch vor sich.
+      if (stack.at(-1) !== id) return
+      stack = stack.filter(x => x !== id)
+      if (close.current() === false) {
+        stack.push(id)
+        push()
+      }
+    }
+
+    window.addEventListener('popstate', onPop)
+    return () => {
+      window.removeEventListener('popstate', onPop)
+      // Geschlossen wurde über einen Knopf oder die Escape-Taste: Unser
+      // Eintrag steht noch im Verlauf und muss weg, sonst bräuchte die
+      // Zurück-Geste danach einen Schritt ins Leere.
+      if (stack.at(-1) === id) {
+        stack = stack.filter(x => x !== id)
+        window.history.back()
+      } else {
+        stack = stack.filter(x => x !== id)
+      }
+    }
+  }, [active])
+}