Installable app, push notifications about new mail, Install app entry

The webmail is now a PWA: web app manifest, icons (any + maskable, a status-bar
badge), theme-coloured title bar following the chosen theme, and an app-icon
badge with the unread Inbox count. The service worker is always installed;
offline access is on only when it is registered as /sw.js?offline=1, so
turning it on or off is an update that applies at once.

Notifications (Settings → Accounts → Notifications, per device) use Web Push.
Encryption (RFC 8291) and VAPID signing (RFC 8292) are implemented in
app/push/webpush.py — pywebpush needs a newer cryptography than we pin — and
checked against the RFC's worked example. The server makes its key pair on
first use (private half encrypted with MASTER_KEY). New mail found by the live
sync in an Inbox enqueues a job 5 s later that tells the user's devices about
messages still unread there, under 2 hours old and not from the user; more
than three become one "N new messages". A subscription belongs to the session
it was made under: signed out or revoked, nothing more is sent there. Endpoints
are limited to the known push services (no SSRF). Nothing shows while the app
is in front (except on Apple, which requires it). Tested with real pushes
through Google's service in Chromium and Opera.

The mobile drawer gets "Install app": Chrome's own install dialog where the
browser offers one, else short steps for iPhone/iPad, Opera and Firefox, with
"Don't show this again". docs/nas-install.md §5.3 covers installing,
notifications, Public URL and a later Android app (TWA).

Migration 0022: push_subscriptions, app_settings.vapid_*.

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

backend/tests/sync/test_secondary_poll.py

@@ -317,3 +317,57 @@ async def test_server_side_flag_change_updates_the_thread_counters() -> None:
             await cleanup.execute(delete(User).where(User.id == user.id))
         await session.close()
         await engine.dispose()
+
+
+async def test_new_inbox_mail_while_live_asks_for_a_push(monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    """New mail found by the live sync in an Inbox enqueues the new-mail push
+    (app/push); new mail in any other folder does not."""
+    from app.push import service as push_service
+
+    asked: list[tuple[uuid.UUID, list[uuid.UUID]]] = []
+
+    async def record(user_id: uuid.UUID, ids: list[uuid.UUID]) -> None:
+        asked.append((user_id, ids))
+
+    monkeypatch.setattr(push_service, "enqueue_new_mail", record)
+    engine = create_async_engine(get_settings().database_url, poolclass=NullPool)
+    session = async_sessionmaker(engine, expire_on_commit=False)()
+    user = User(handle=f"psh{uuid.uuid4().hex[:8]}@test.local", password_hash=hash_password("pw"))
+    session.add(user)
+    await session.flush()
+    account = Account(
+        user_id=user.id,
+        email="me@example.com",
+        imap_config={},
+        smtp_config={},
+        secret_ct=b"",
+        discovery_src="manual",
+    )
+    session.add(account)
+    await session.flush()
+    inbox = Mailbox(account_id=account.id, user_id=user.id, path="INBOX", special_use="inbox")
+    sent = Mailbox(account_id=account.id, user_id=user.id, path="SENT", special_use="sent")
+    session.add_all([inbox, sent])
+    await session.commit()
+
+    class FakeProvider:
+        async def close(self) -> None:
+            return None
+
+    def delta(uid: int, mid: str) -> MailboxDelta:
+        msg = RemoteMessage(
+            uid=uid, raw=_raw("Hi", mid), flags=frozenset(), internal_date=datetime.now(UTC)
+        )
+        return MailboxDelta([msg], [], [], None, None)
+
+    try:
+        await sync_engine.apply_delta(FakeProvider(), account, sent, delta(3, "<p1@x.com>"))  # type: ignore[arg-type]
+        assert asked == []
+        await sync_engine.apply_delta(FakeProvider(), account, inbox, delta(4, "<p2@x.com>"))  # type: ignore[arg-type]
+        new_id = await session.scalar(select(Message.id).where(Message.mailbox_id == inbox.id))
+        assert asked == [(user.id, [new_id])]
+    finally:
+        async with session_scope() as cleanup:
+            await cleanup.execute(delete(User).where(User.id == user.id))
+        await session.close()
+        await engine.dispose()