docs(waterdata): correct interruption claims to include transport errors

Module docstring, ChunkedCall.resume() Raises, and ChunkedCall._run
all listed only 429/5xx as the failures that raise ChunkInterrupted,
but _classify_chunk_error also wraps bare httpx.HTTPError (ConnectError,
TimeoutException, RemoteProtocolError, ...) and httpx.InvalidURL as
ServiceInterrupted (chunking.py:1098). So callers who only caught the
429/5xx case per the docs could miss the transport-error path.

Fix: list transport errors alongside 429/5xx in all three docstrings,
and name QuotaExhausted vs ServiceInterrupted by which case maps
where.

Surfaced by a docs-vs-code audit; no functional change.

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

Author: thodson-usgs

dataretrieval/waterdata/chunking.py

@@ -30,9 +30,10 @@
 the resumable interruption below so a multi-minute quota-window
 reset doesn't block the call.
 
-Interruption: any mid-stream transient failure (429, 5xx) surfaces
-as a ``ChunkInterrupted`` subclass — ``QuotaExhausted`` for 429,
-``ServiceInterrupted`` for 5xx. The exception carries ``.call``, a
+Interruption: any mid-stream transient failure — 429, 5xx, or a bare
+transport error (connect/read timeout, oversize follow-up URL) — surfaces
+as a ``ChunkInterrupted`` subclass: ``QuotaExhausted`` for 429,
+``ServiceInterrupted`` for the rest. The exception carries ``.call``, a
 ``ChunkedCall`` handle that owns the already-completed sub-request
 state (sparse-indexed, since gathered sub-requests complete out of
 order). Call ``.call.resume()`` once the underlying condition clears;
@@ -1596,11 +1597,11 @@ def resume(self) -> tuple[pd.DataFrame, Any]:
         Raises
         ------
         ChunkInterrupted
-            On a mid-stream transient failure
-            (:class:`QuotaExhausted` for 429,
-            :class:`ServiceInterrupted` for 5xx). The resumable handle
-            is on ``exc.call`` — wait for the underlying condition to
-            clear and call ``exc.call.resume()`` again.
+            On a mid-stream transient failure — 429, 5xx, or a bare
+            transport error: :class:`QuotaExhausted` for 429,
+            :class:`ServiceInterrupted` for the rest. The resumable
+            handle is on ``exc.call`` — wait for the underlying
+            condition to clear and call ``exc.call.resume()`` again.
         """
         concurrency = _read_concurrency_env()
         with start_blocking_portal() as portal:
@@ -1613,8 +1614,9 @@ async def _run(self, max_concurrent: int | None) -> tuple[pd.DataFrame, Any]:
 
         Pending sub-requests (:meth:`_pending`) fan out under
         ``asyncio.gather`` with ``return_exceptions=True`` so completed
-        sub-requests survive a sibling's transient failure. On a recognized
-        transient (:class:`RateLimited`, :class:`ServiceUnavailable`) a
+        sub-requests survive a sibling's transient failure. On a
+        recognized transient (:class:`RateLimited`, :class:`ServiceUnavailable`,
+        or a bare ``httpx.HTTPError`` / ``httpx.InvalidURL``) a
         :class:`ChunkInterrupted` subclass is raised carrying ``self`` on
         ``.call``; ``exc.call.resume()`` then re-issues only the unfinished
         indices through this same runner.