docs: Remove from_config(), just expose conn.config

Simpler API:
- Use existing Connection() constructor
- conn.config copies from global dj.config
- conn.config is always mutable for per-connection settings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

docs/design/thread-safe-mode.md

@@ -6,7 +6,7 @@ DataJoint uses global state (`dj.config`, `dj.conn()`) that is not thread-safe.
 
 ## Solution
 
-Add `thread_safe` mode that makes global config read-only and requires explicit connections with mutable connection-scoped settings.
+Add `thread_safe` mode that makes global config read-only and provides connection-scoped mutable settings via `conn.config`.
 
 ## API
 
@@ -23,64 +23,60 @@ export DJ_THREAD_SAFE=true
 {"thread_safe": true}
 ```
 
-### Connection.from_config()
-
-Creates a connection with explicit configuration. Works in both modes.
+### Create Connections
 
 ```python
-conn = dj.Connection.from_config(
+conn = dj.Connection(
     host="localhost",
     user="user",
     password="password",
-    safemode=False,
-    display_limit=25,
 )
+
+# Modify settings per-connection
+conn.config.safemode = False
+conn.config.display_limit = 25
+
 schema = dj.Schema("my_schema", connection=conn)
 ```
 
-**Parameters:**
-- `host` (required): Database hostname
-- `user` (required): Database username
-- `password` (required): Database password
-- `port`: Database port (default: 3306)
-- Any other setting (e.g., `safemode`, `display_limit`, `stores`)
+### conn.config
 
-**Config creation:** Copies global `dj.config`, then applies kwargs. Creates `conn.config` which is always mutable.
+Every connection has a `config` attribute that:
+- Copies from global `dj.config` at connection time
+- Is always mutable (even in thread-safe mode)
+- Provides connection-scoped settings
 
 ```python
-conn = dj.Connection.from_config(host="localhost", user="u", password="p")
-conn.config.safemode = False      # Always OK: conn.config is mutable
-conn.config.display_limit = 25    # Always OK
+conn.config.safemode         # Read setting
+conn.config.safemode = False # Write setting (always allowed)
+conn.config.stores = {...}   # Configure stores for this connection
 ```
 
 ## Behavior
 
 | Operation | `thread_safe=False` | `thread_safe=True` |
 |-----------|--------------------|--------------------|
-| `dj.config` read | Works | Works (read-only) |
+| `dj.config` read | Works | Works |
 | `dj.config` write | Works | Raises `ThreadSafetyError` |
 | `dj.conn()` | Works | Raises `ThreadSafetyError` |
 | `dj.Schema("name")` | Works | Raises `ThreadSafetyError` |
-| `Connection.from_config()` | Works | Works |
+| `dj.Connection(...)` | Works | Works |
 | `conn.config` read/write | Works | Works |
 | `Schema(..., connection=conn)` | Works | Works |
 
 ## Read-Only Settings
 
-- `thread_safe`: Always read-only after initialization (set via env var or config file only)
+- `thread_safe`: Always read-only (set via env var or config file only)
 - All of `dj.config`: Read-only when `thread_safe=True`
 
 ## Implementation
 
 1. Add `thread_safe: bool = False` field to `Config` with `DJ_THREAD_SAFE` env alias
 2. Make `thread_safe` always read-only after initialization
-3. When `thread_safe=True`, make all `dj.config` writes raise `ThreadSafetyError`
+3. When `thread_safe=True`, make `dj.config` writes raise `ThreadSafetyError`
 4. Add guard to `dj.conn()`
 5. Add guard to `Schema.__init__` when `connection=None`
-6. Add `Connection.from_config()` class method that:
-   - Copies global `dj.config`
-   - Applies kwargs overrides
-   - Creates mutable `conn.config`
+6. Add `conn.config` to `Connection` that copies from global `dj.config`
 7. Add `ThreadSafetyError` exception
 
 ## Exceptions
@@ -92,5 +88,5 @@ class ThreadSafetyError(DataJointError):
 
 Error messages:
 - Config write: `"Global config is read-only in thread-safe mode. Use conn.config for connection-scoped settings."`
-- `dj.conn()`: `"dj.conn() is disabled in thread-safe mode. Use Connection.from_config()."`
+- `dj.conn()`: `"dj.conn() is disabled in thread-safe mode. Use Connection() with explicit parameters."`
 - Schema without connection: `"Schema requires explicit connection in thread-safe mode."`