Clarify ClusterClient ownership contract

Expand ConnectionPool.__init__ docstring to state who closes the
cluster, whether sharing across pools is safe, and what pool.close()
actually does. Previous docstring said only "Externally-owned
ClusterClient" which left three questions unanswered:

- Does pool.close() close the cluster?    Answer: no.
- May one cluster back many pools?        Answer: yes.
- Is out-of-pool use of the cluster safe? Answer: yes, each
  leader-query opens a short-lived socket that does not contend with
  pool checkout.

Also clarifies that when the pool constructs its own cluster (from
node_store= or addresses=), pool.close() still does not close it —
leader-query sockets are short-lived, and the NodeStore is
caller-owned.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/pool.py

@@ -75,8 +75,24 @@ def __init__(
             cluster: Externally-owned ClusterClient. Lets multiple pools
                 share one ClusterClient (and thus its node store, leader
                 cache, etc.) across databases or tenants.
+
+                Ownership: the pool does NOT take ownership of this
+                cluster. The caller is responsible for eventually calling
+                ``cluster.close()`` and MUST NOT close the cluster while
+                any pool is still in use. ``pool.close()`` does not close
+                the cluster — it only drains pool-owned connections.
+
+                Sharing: one ClusterClient may back multiple pools
+                concurrently. Direct use of the cluster (e.g.,
+                ``await cluster.find_leader()``) from outside the pool is
+                safe — each call opens a short-lived leader-query socket
+                and does not contend with pool checkout.
             node_store: Externally-owned NodeStore used to build a new
-                ClusterClient. Mutually exclusive with ``cluster``.
+                ClusterClient. Mutually exclusive with ``cluster``. Note
+                that ``pool.close()`` does not close this auto-constructed
+                cluster either — leader-query sockets it opens are
+                short-lived and close on their own; the NodeStore itself
+                is caller-owned.
             max_total_rows: Cumulative row cap across continuation
                 frames for a single query. Forwarded to every
                 :class:`DqliteConnection` the pool hands out, so every