fix: CAST(BOOLEAN AS numeric) rejected — true/false now cast to 1/0

BOOLEAN -> INTEGER/BIGINT/FLOAT/DOUBLE failed: the cast string-
roundtripped ('true'/'false') and the numeric parser rejected it.

  CAST(true AS INT)     -> "Cannot cast 'true' to INTEGER" (was)
                        -> 1 (now)
  CAST(false AS DOUBLE) -> error                            -> 0
  SUM(CAST(pred AS INT)) -> error                           -> count

Symmetric counterpart to the numeric->BOOLEAN cast (commit 189342b).
Postgres/DuckDB: true -> 1, false -> 0.

Fix: typed BOOLEAN -> numeric branch in ExecuteCast, before the
string fallback. Covers TINYINT/SMALLINT/INTEGER/BIGINT/FLOAT/DOUBLE.

Verified manually:
  CAST(true AS INT) / CAST(false AS INT)   -> 1 / 0
  CAST(true AS BIGINT) / (false AS DOUBLE) -> 1 / 0
  int->bool->int roundtrip                 -> 1
  SUM(CAST(x>1 AS INT))                     -> counts predicate
  Regression int->bool / varchar->bool     -> unchanged
  Regression int->varchar                  -> unchanged

Zero physical_planner.cpp fast-path dispatch impact. ExecuteCast
branch only.

This is the architect-spawn pattern's hidden-bug-find for the round:
the SUM(CAST(predicate AS INT)) counting idiom — extremely common
for conditional counts — was completely blocked by the missing
BOOLEAN->numeric cast.

Author: SouravRoy-ETL

src/execution/expression_executor.cpp

@@ -4604,6 +4604,27 @@ void ExpressionExecutor::ExecuteCast(const BoundCast &expr, DataChunk &input,
                 }
                 continue;
             }
+            // BOOLEAN -> numeric (Postgres/DuckDB): true -> 1, false -> 0.
+            // Previously the cast string-roundtripped ('true'/'false')
+            // and the numeric parser rejected it.
+            if (from_type == LogicalTypeId::BOOLEAN &&
+                (to_type == LogicalTypeId::TINYINT ||
+                 to_type == LogicalTypeId::SMALLINT ||
+                 to_type == LogicalTypeId::INTEGER ||
+                 to_type == LogicalTypeId::BIGINT ||
+                 to_type == LogicalTypeId::FLOAT ||
+                 to_type == LogicalTypeId::DOUBLE)) {
+                bool b = val.GetValue<bool>();
+                switch (to_type) {
+                case LogicalTypeId::TINYINT:  result.SetValue(i, Value::TINYINT(b ? 1 : 0)); break;
+                case LogicalTypeId::SMALLINT: result.SetValue(i, Value::SMALLINT(b ? 1 : 0)); break;
+                case LogicalTypeId::INTEGER:  result.SetValue(i, Value::INTEGER(b ? 1 : 0)); break;
+                case LogicalTypeId::BIGINT:   result.SetValue(i, Value::BIGINT(b ? 1 : 0)); break;
+                case LogicalTypeId::FLOAT:    result.SetValue(i, Value::FLOAT(b ? 1.0f : 0.0f)); break;
+                default:                      result.SetValue(i, Value::DOUBLE(b ? 1.0 : 0.0)); break;
+                }
+                continue;
+            }
             auto str = val.ToString();
             switch (to_type) {
             case LogicalTypeId::TINYINT: