refactor: add @_disfavoredOverload to .min()/.max() methods in BasicMath

Added `@_disfavoredOverload` attribute to QueryExpression.min() and
QueryExpression.max() methods to prevent conflicts with Swift's stdlib
Sequence.min() and Sequence.max() methods.

Changes:
- Added @_disfavoredOverload to all four .min()/.max() methods in BasicMath.swift
- Added documentation explaining the disambiguation approach
- Created comprehensive test suite (BasicMathTests.swift) with 25 tests
- Tests demonstrate both Swift stdlib and SQL methods working together
- All 860 tests passing (including 25 new tests)

Benefits:
- Users can use Swift's .min()/.max() on regular Swift collections
- Users can use SQL's .min()/.max() on QueryExpression types
- No explicit type annotations needed
- Consistent with existing .joined() disambiguation pattern

Author: coenttb

Sources/StructuredQueriesPostgres/Functions/Mathematical/BasicMath.swift

@@ -278,6 +278,9 @@ extension QueryExpression where QueryValue: Comparable & QueryBindable {
     /// ```
     ///
     /// > Note: For finding minimum across multiple values, use `least()` function.
+    /// > The `@_disfavoredOverload` attribute ensures Swift's stdlib `Sequence.min()` is preferred
+    /// > for regular Swift collections, while this method is available for QueryExpressions.
+    @_disfavoredOverload
     public func min(_ other: QueryValue) -> some QueryExpression<QueryValue> {
         SQLQueryExpression(
             "least(\(self.queryFragment), \(bind: other))",
@@ -288,6 +291,10 @@ extension QueryExpression where QueryValue: Comparable & QueryBindable {
     /// Returns the smaller of two expression values
     ///
     /// PostgreSQL's `least()` function for two values.
+    ///
+    /// > Note: The `@_disfavoredOverload` attribute ensures Swift's stdlib `Sequence.min()` is preferred
+    /// > for regular Swift collections, while this method is available for QueryExpressions.
+    @_disfavoredOverload
     public func min(_ other: some QueryExpression<QueryValue>) -> some QueryExpression<QueryValue> {
         SQLQueryExpression(
             "least(\(self.queryFragment), \(other.queryFragment))",
@@ -305,6 +312,9 @@ extension QueryExpression where QueryValue: Comparable & QueryBindable {
     /// ```
     ///
     /// > Note: For finding maximum across multiple values, use `greatest()` function.
+    /// > The `@_disfavoredOverload` attribute ensures Swift's stdlib `Sequence.max()` is preferred
+    /// > for regular Swift collections, while this method is available for QueryExpressions.
+    @_disfavoredOverload
     public func max(_ other: QueryValue) -> some QueryExpression<QueryValue> {
         SQLQueryExpression(
             "greatest(\(self.queryFragment), \(bind: other))",
@@ -315,6 +325,10 @@ extension QueryExpression where QueryValue: Comparable & QueryBindable {
     /// Returns the larger of two expression values
     ///
     /// PostgreSQL's `greatest()` function for two values.
+    ///
+    /// > Note: The `@_disfavoredOverload` attribute ensures Swift's stdlib `Sequence.max()` is preferred
+    /// > for regular Swift collections, while this method is available for QueryExpressions.
+    @_disfavoredOverload
     public func max(_ other: some QueryExpression<QueryValue>) -> some QueryExpression<QueryValue> {
         SQLQueryExpression(
             "greatest(\(self.queryFragment), \(other.queryFragment))",