refactor: invert server dependencies onto interfaces (DIP)

[RaoulSchaffranek]

Addresses the dependency-inversion gap: StellarRpcServer hard-constructed its collaborators (NodeInterpreter(), TransactionEncoder(...), ChainStore(...)) in __init__, so there was no seam to substitute fakes — the server's dispatch/validation/response logic couldn't be exercised without the compiled K interpreter. Stacked on #44 (retarget to main as #43 → #44 → this merge in order). make check clean, all 90 tests pass.

The inversion

New interfaces.py — the abstraction layer. Holds the collaborator Protocols (Interpreter, Encoder, Store) plus the shared data shapes (TxRequest, SimulateRequest, SimulateResult, LedgerRecord, EventRecord), moved out of transaction.py/store.py/server.py so both the protocols and the concretes can share them without importing each other.

server.py depends only on abstractions. __init__ now takes interpreter / encoder / store injected, typed against the protocols; the module imports none of the concrete classes. Verified:

$ grep -E 'import (NodeInterpreter|TransactionEncoder|ChainStore)' server.py
(nothing)

Concretes declare conformance. NodeInterpreter(Interpreter), TransactionEncoder(Encoder), ChainStore(Store) — so mypy flags any drift between a concrete and the protocol the server relies on. This is the correct DIP direction: the low-level details depend on the abstraction.

Composition roots wire the concretes:

• build_server() in __main__.py — production root; owns the default temp io-dir behavior that used to live in the server.
• the server fixture in conftest.py — test root, wiring concretes explicitly on tmp_path.

The server's own network_passphrase / io_dir constructor params are gone — those now belong to the encoder and store that the composition root builds.

Dependency graph after

interfaces  ←  server, interpreter, transaction, store   (all depend on the abstractions)
__main__    →  server + the three concretes              (composition root)

The server no longer has a construction edge to any collaborator.

Testability payoff

A unit test can now drive StellarRpcServer(interpreter=Fake(), encoder=..., store=...) with a K-free fake interpreter and exercise dispatch/validation/error-mapping without the compiled semantics. Per our discussion I did not add such a test here (refactor-only); the seam is in place for follow-up.

Test changes (consequences of the refactor, not new coverage)

• conftest.server wires the concretes; added a shared contract_address_from_deployer helper so the two sites that reached through server.encoder for it no longer depend on the concrete encoder type.
• test_default_io_dir_is_a_fresh_temp_dir drives build_server (the temp-dir default moved there).

Deliberately out of scope

NodeInterpreter still constructs its own simbolik_definition() internally. With the Interpreter protocol that's no longer a testability blocker (fake the whole interpreter), so I left it; easy follow-up to inject the definition if wanted.