fix(key-backup): count only the sessions actually written (#87)

Review finding on #77, after merge.

The import counted every session it decrypted:

```python
client.olm.store.save_inbound_group_session(session)
imported += 1
```

`save_inbound_group_session` ends in an `on_conflict_ignore()` insert,
so a session already in the store is reported as imported while nothing
is written. The run that produced #77 printed `Imported: 18275` against
18272 new rows — three were already there and counted anyway.

That is the same defect #77 was written to fix, one size smaller: the
original code counted sessions it *discarded*, and the inflated number
is what kept it invisible.

Sessions now go through `client.olm.inbound_group_store.add()` first,
which is what nio does when it imports a key itself:

```python
if self.inbound_group_store.add(session):
    self.save_inbound_group_session(session)
```

`add()` returns False for a session already held, and `Olm.load()`
populates that in-memory set from the database at startup — which the
script triggers via `client.load_store()`. So a re-import reports what
it actually did instead of claiming the whole backup again.

Sessions already present are reported on their own line, and a run where
everything was already in the store no longer exits non-zero.

## Not covered by a test

The path needs a live backup and a real megolm session; there is no
fixture for either in this repo. The claim rests on nio's own source
(`on_conflict_ignore` in `store/database.py`, the `add()`-then-save
pattern in `crypto/olm_machine.py`) and on the counter mismatch observed
against a live backup. Worth saying plainly rather than implying the
change is covered.

Author: CybotTM

skills/matrix-communication/scripts/matrix-key-backup.py

@@ -460,6 +460,7 @@ async def main():
             await client.sync(timeout=5000)
 
             imported = 0
+            already_present = 0
             failed = 0
 
             # room_id is part of the megolm session identity, so it has to come
@@ -485,10 +486,22 @@ async def main():
                             room_id,
                             decrypted.get("forwarding_curve25519_key_chain") or [],
                         )
-                        client.olm.store.save_inbound_group_session(session)
 
-                        imported += 1
-                        if imported % 500 == 0:
+                        # Go through the in-memory store first, the way nio does
+                        # when it imports a key itself. add() returns False for a
+                        # session already held, and the database write is an
+                        # on_conflict_ignore insert - so counting every decrypted
+                        # session as imported would report writes that never
+                        # happened. Sessions loaded from the store at startup are
+                        # in that in-memory set, which is what makes this honest
+                        # on a re-import.
+                        if client.olm.inbound_group_store.add(session):
+                            client.olm.store.save_inbound_group_session(session)
+                            imported += 1
+                        else:
+                            already_present += 1
+
+                        if imported and imported % 500 == 0:
                             print(f"  Imported {imported} sessions...")
 
                     except Exception as e:  # noqa: BLE001  # intentional fail-soft: error surfaced to caller, not re-raised
@@ -498,8 +511,10 @@ async def main():
 
             print("\n=== Import Complete ===")
             print(f"Imported: {imported}")
+            if already_present:
+                print(f"Already in the store: {already_present}")
             print(f"Failed: {failed}")
-            if failed and not imported:
+            if failed and not imported and not already_present:
                 return 1
 
         finally: