PERF: Optimize Row construction and repeated cursor bookkeeping (#558)

### Work Item / Issue Reference
<!--
IMPORTANT: Please follow the PR template guidelines below.
For mssql-python maintainers: Insert your ADO Work Item ID below
For external contributors: Insert Github Issue number below
Only one reference is required - either GitHub issue OR ADO Work Item.
-->

<!-- mssql-python maintainers: ADO Work Item -->
>
[AB#44921](https://sqlclientdrivers.visualstudio.com/c6d89619-62de-46a0-8b46-70b92a84d85e/_workitems/edit/44921)

<!-- External contributors: GitHub Issue -->

### Summary
Reduce Python-side overhead in `fetchone()`, `fetchmany()`, and
`fetchall()` while preserving decoding, converter, diagnostic, and
Row-access behavior. The branch incorporates main through `e279a4f6` and
includes the review fixes in `56c3d3b5`.

#### Fetch optimizations
- Construct eligible `fetchmany()`/`fetchall()` rows in native
`construct_rows`, bypassing the Python per-row initialization loop. Use
`Row._fast_create()` for the corresponding `fetchone()` path.
- Add `Row.__slots__` and retain zero-copy storage of fetched values
when no conversion is required. Initialize the shared lowercase column
map on both Python and native construction paths.
- Cache CHAR/WCHAR encoding strings and the CHAR C type. Refresh them
only when connection decoding settings change, including for existing
cursors.
- Reuse the SQL-to-C type mapping and use `str.isascii()` for Unicode
detection.
- Keep the no-conversion fast path available when converters are
registered but none applies to the current result set. An explicit empty
mapping avoids unnecessary row copies or per-row fallback lookups.

#### Correctness and compatibility
- Track converter-generation changes so adding, replacing, removing, or
clearing converters after `execute()` updates subsequent fetches without
rebuilding mappings on unchanged cache hits.
- Preserve current-main dispatch precedence: raw ODBC SQL type, Python
type, then the string/bytes-only WVARCHAR fallback. Unrelated integer
and UUID columns are not passed to the string fallback.
- Preserve direct `Row` construction's connection-converter fallback
when no precomputed mapping is supplied, including UUID stringification.
- Retain main's lowercase/string-key column access, profiling scopes,
and CHAR decoding C-type forwarding. Native WCHAR decoding semantics are
unchanged.
- Validate `row_class` with `PyType_Check` before casting in the
Python-callable native helper. Invalid arguments raise `TypeError`
rather than crashing the interpreter.
- Restore unconditional diagnostic retrieval after non-error fetch
returns. The native wrappers can overwrite intermediate statuses, so
checking only the final `SQL_SUCCESS_WITH_INFO` is unsafe. The earlier
diagnostic-skip optimization has been removed; this restores prior
behavior rather than claiming to repair pre-existing native
diagnostic-record overwrites.
- Check errors in `fetchone()` and `fetchmany()` before updating row
positions or constructing rows, consistent with `fetchall()`.

### Performance: current main versus this PR

| Workload (rows x columns) | API | Main median | PR median | Time
reduction |
|---|---|---:|---:|---:|
| Narrow: 10,000 x 3 | `fetchmany(1000)` | 9.36 ms | 6.54 ms |
**30.18%** |
| Narrow: 10,000 x 3 | `fetchall()` | 8.67 ms | 6.99 ms | **19.30%** |
| Wide: 10,000 x 24 | `fetchmany(1000)` | 27.57 ms | 24.72 ms |
**10.34%** |
| Wide: 10,000 x 24 | `fetchall()` | 30.59 ms | 26.07 ms | **14.79%** |

Positive reduction means less time, calculated from unrounded medians.
Narrow/wide batch cases improved in 10/10 and 9/10 pairs respectively.
`fetchmany(1)` medians were only 1.15-1.80% lower, with narrow results
inconclusive. Narrow `fetchone()` was 5.02% lower; wide `fetchone()`.

These are workload-specific results, not a universal or cross-platform
speedup. Full results for all 11 fetch cases, control, dispersion,
paired intervals, build identities, and raw repetitions are retained
locally; older pre-merge numbers are not mixed in.

---------

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Gaurav Sharma <sharmag@microsoft.com>

Author: 3 people

mssql_python/connection.py

@@ -540,6 +540,7 @@ def __init__(
                 "ctype": ConstantsDDBC.SQL_WCHAR.value,
             },
         }
+        self._decoding_generation = 0
 
         # Auth type for acquiring fresh tokens at bulk copy time.
         # We intentionally do NOT cache the token — a fresh one is acquired
@@ -782,6 +783,7 @@ def _token_factory():
 
         # Initialize output converters dictionary and its lock for thread safety
         self._output_converters = {}
+        self._converters_generation = 0
         self._converters_lock = threading.Lock()
 
         # Initialize encoding/decoding settings lock for thread safety
@@ -1320,6 +1322,9 @@ def setdecoding(
         """
         Sets the text decoding used when reading SQL_CHAR and SQL_WCHAR from the database.
 
+        Existing cursors refresh their cached SQL_CHAR/SQL_WCHAR decoding settings
+        before their next fetch.
+
         This method configures how text data is decoded when reading from the database.
         In Python 3, all text is Unicode (str), so this primarily affects the encoding
         used to decode bytes from the database.
@@ -1443,6 +1448,7 @@ def setdecoding(
         # Store the decoding settings for the specified sqltype (thread-safe with lock)
         with self._encoding_lock:
             self._decoding_settings[sqltype] = {"encoding": encoding, "ctype": ctype}
+            self._decoding_generation += 1
 
         # Log with sanitized values for security
         sqltype_name = {
@@ -1647,6 +1653,8 @@ def add_output_converter(self, sqltype: Union[int, type], func: Callable[[Any],
 
         Thread-safe implementation that protects the converters dictionary with a lock.
 
+        Changes apply on the next fetch, including for an already executed result set.
+
         ⚠️ WARNING: Registering an output converter will cause the supplied Python function
         to be executed on every matching database value. Do not register converters from
         untrusted sources, as this can result in arbitrary code execution and security
@@ -1687,6 +1695,7 @@ def add_output_converter(self, sqltype: Union[int, type], func: Callable[[Any],
         """
         with self._converters_lock:
             self._output_converters[sqltype] = func
+            self._converters_generation += 1
             # Pass to the underlying connection if native implementation supports it
             if hasattr(self._conn, "add_output_converter"):
                 self._conn.add_output_converter(sqltype, func)
@@ -1717,6 +1726,8 @@ def remove_output_converter(self, sqltype: Union[int, type]) -> None:
 
         Thread-safe implementation that protects the converters dictionary with a lock.
 
+        Existing cursors use the updated converters on their next fetch.
+
         Args:
             sqltype (int or type): The SQL type value to remove the converter for
 
@@ -1726,6 +1737,7 @@ def remove_output_converter(self, sqltype: Union[int, type]) -> None:
         with self._converters_lock:
             if sqltype in self._output_converters:
                 del self._output_converters[sqltype]
+                self._converters_generation += 1
                 # Pass to the underlying connection if native implementation supports it
                 if hasattr(self._conn, "remove_output_converter"):
                     self._conn.remove_output_converter(sqltype)
@@ -1737,11 +1749,14 @@ def clear_output_converters(self) -> None:
 
         Thread-safe implementation that protects the converters dictionary with a lock.
 
+        Existing cursors stop applying converters on their next fetch.
+
         Returns:
             None
         """
         with self._converters_lock:
             self._output_converters.clear()
+            self._converters_generation += 1
             # Pass to the underlying connection if native implementation supports it
             if hasattr(self._conn, "clear_output_converters"):
                 self._conn.clear_output_converters()