Fixes chroma-core#5868

Added close() method to the Client class that properly releases resources
by calling self._system.stop(). This is essential for PersistentClient to
avoid SQLite file locking issues when uploading database files to S3 or
performing other operations that require exclusive file access.

Also implemented context manager support (__enter__ and __exit__) to
enable the "with" statement pattern for automatic resource cleanup.

Changes:
- Added Client.close() method that stops the underlying system
- Added __enter__ and __exit__ methods for context manager support
- Added comprehensive tests for both close() and context manager usage
- Tests cover both PersistentClient and EphemeralClient

Example usage:
```python
# Explicit close
client = chromadb.PersistentClient(path="./chroma_db")
# ... use client ...
client.close()

# Context manager
with chromadb.PersistentClient(path="./chroma_db") as client:
    # ... use client ...
# Automatically closed
```

- Add reference counting to SharedSystemClient to track multiple clients
  using the same System instance
- Only stop() the System when the last client calls close()
- This fixes the issue where closing one client would break other clients
  sharing the same System (e.g., multiple PersistentClient instances with
  the same path)
- Add proper type annotations to __exit__ method parameters
- Update clear_system_cache() to also clear reference counts

This addresses the propel-code-bot feedback on PR chroma-core#6373 which identified
that the shared System singleton needs reference counting to avoid
invalidating other clients when one closes.

Use pop() instead of direct dict access so that calling close()
multiple times (common with context managers + explicit close) is
a safe no-op instead of raising KeyError.

…d safety

- Fix off-by-one: AdminClient created in Client.__init__ also increments
  refcount for the same shared system. close() now decrements the admin
  client's refcount before decrementing its own, so the system properly
  stops when the last client closes.

- Fix resource leak: if Client.__init__ raises after super().__init__()
  increments the refcount, the caller never gets the object to call
  close(). Wrap the init body in try/except to decrement on failure.

- Fix race condition: += and -= on dict values are not atomic. Protect
  _identifier_to_refcount with a class-level threading.Lock.

- Add _closed flag to make close() fully idempotent without relying on
  refcount state.

Stop and remove the System from cache when init fails and refcount drops
to zero, preventing orphaned running systems. Fix tests to save a local
reference to the System before close() since close() pops it from the
shared cache.

Extract the duplicated "decrement refcount + conditional stop" pattern
from both Client.close() and the Client.__init__ exception handler
into SharedSystemClient._release_system(). This eliminates code
duplication and ensures consistent cleanup behavior in both paths.