refactor: organize CASE expressions under Conditional namespace

Resolves namespace collision by separating domain (Conditional) from constructor (Case).

Structure:
- Conditional.swift: namespace enum + global Case() constructors
- Conditional.Case.swift: main CASE expression builder
- Conditional.Builder.swift: intermediate builder with accumulated WHEN clauses
- Conditional.When.swift: WHEN...THEN clause helper

Key insight: Namespaces should describe domains (Conditional), not constructors (Case).
This allows Case() to function as an ergonomic global constructor without conflicts.

API:
- Case() - beautiful ergonomic syntax (no conflicts!)
- Conditional.Case<Base, QueryValue> - properly namespaced type
- Conditional.Builder, Conditional.When - semantic organization

Follows Point-Free principle: namespace the domain, expose ergonomic constructors.

Author: coenttb

Sources/StructuredQueriesPostgres/Functions/Conditional/CaseExpression.swift

@@ -0,0 +1,66 @@
+import StructuredQueriesCore
+
+extension Conditional {
+    /// A `CASE` expression builder with accumulated WHEN clauses.
+    public struct Builder<Base, QueryValue: _OptionalProtocol>: QueryExpression {
+        var base: QueryFragment?
+        var cases: [QueryFragment]
+
+        /// Adds a `WHEN` clause to a `CASE` expression.
+        ///
+        /// - Parameters:
+        ///   - condition: A condition to test.
+        ///   - expression: A return value should the condition pass.
+        /// - Returns: A `CASE` expression builder.
+        public func when(
+            _ condition: some QueryExpression<Base>,
+            then expression: some QueryExpression<QueryValue>
+        ) -> Conditional.Builder<Base, QueryValue> {
+            var cases = self
+            cases.cases.append(
+                Conditional.When(predicate: condition.queryFragment, expression: expression.queryFragment)
+                    .queryFragment
+            )
+            return cases
+        }
+
+        /// Adds a `WHEN` clause to a `CASE` expression.
+        ///
+        /// - Parameters:
+        ///   - condition: A condition to test.
+        ///   - expression: A return value should the condition pass.
+        /// - Returns: A `CASE` expression builder.
+        public func when(
+            _ condition: some QueryExpression<Base>,
+            then expression: some QueryExpression<QueryValue.Wrapped>
+        ) -> Conditional.Builder<Base, QueryValue> {
+            var cases = self
+            cases.cases.append(
+                Conditional.When(predicate: condition.queryFragment, expression: expression.queryFragment)
+                    .queryFragment
+            )
+            return cases
+        }
+
+        /// Terminates a `CASE` expression with an `ELSE` clause.
+        ///
+        /// - Parameter expression: A return value should every `WHEN` condition fail.
+        /// - Returns: A `CASE` expression.
+        public func `else`(
+            _ expression: some QueryExpression<QueryValue.Wrapped>
+        ) -> some QueryExpression<QueryValue.Wrapped> {
+            var cases = self
+            cases.cases.append("ELSE \(expression)")
+            return SQLQueryExpression(cases.queryFragment)
+        }
+
+        public var queryFragment: QueryFragment {
+            var query: QueryFragment = "CASE"
+            if let base {
+                query.append(" \(base)")
+            }
+            query.append(" \(cases.joined(separator: " ")) END")
+            return query
+        }
+    }
+}

Sources/StructuredQueriesPostgres/Functions/Conditional/Conditional.Builder.swift

@@ -0,0 +1,63 @@
+import StructuredQueriesCore
+
+extension Conditional {
+    /// A type that builds SQL `CASE` expressions.
+    ///
+    /// ```swift
+    /// Case(5).when(condition1, then: result1)
+    /// // Generates: CASE 5 WHEN condition1 THEN result1 END
+    /// ```
+    public struct Case<Base, QueryValue: _OptionalPromotable> {
+        var base: QueryFragment?
+
+        /// Creates a SQL `CASE` expression builder.
+        ///
+        /// - Parameter base: A "base" expression to test against for each `WHEN`.
+        public init(
+            _ base: some QueryExpression<Base>
+        ) {
+            self.base = base.queryFragment
+        }
+
+        /// Creates a SQL `CASE` expression builder.
+        public init() where Base == Bool {}
+
+        /// Adds a `WHEN` clause to a `CASE` expression.
+        ///
+        /// - Parameters:
+        ///   - condition: A condition to test.
+        ///   - expression: A return value should the condition pass.
+        /// - Returns: A `CASE` expression builder.
+        public func when(
+            _ condition: some QueryExpression<Base>,
+            then expression: some QueryExpression<QueryValue>
+        ) -> Conditional.Builder<Base, QueryValue?> {
+            Conditional.Builder(
+                base: base,
+                cases: [
+                    Conditional.When(predicate: condition.queryFragment, expression: expression.queryFragment)
+                        .queryFragment
+                ]
+            )
+        }
+
+        /// Adds a `WHEN` clause to a `CASE` expression.
+        ///
+        /// - Parameters:
+        ///   - condition: A condition to test.
+        ///   - expression: A return value should the condition pass.
+        /// - Returns: A `CASE` expression builder.
+        public func when(
+            _ condition: some QueryExpression<Base>,
+            then expression: some QueryExpression<QueryValue._Optionalized>
+        ) -> Conditional.Builder<Base, QueryValue._Optionalized> {
+            Conditional.Builder(
+                base: base,
+                cases: [
+                    Conditional.When(predicate: condition.queryFragment, expression: expression.queryFragment)
+                        .queryFragment
+                ]
+            )
+        }
+    }
+}

Sources/StructuredQueriesPostgres/Functions/Conditional/Conditional.Case.swift

@@ -0,0 +1,15 @@
+import StructuredQueriesCore
+
+extension Conditional {
+    /// A WHEN...THEN clause for CASE expressions.
+    struct When: QueryExpression {
+        typealias QueryValue = Never
+
+        let predicate: QueryFragment
+        let expression: QueryFragment
+
+        public var queryFragment: QueryFragment {
+            "WHEN \(predicate) THEN \(expression)"
+        }
+    }
+}