Fixes cockroachdb#93371

Given the query:
```
SET VECTORIZE=off;
WITH RECURSIVE foo(i) AS
    (SELECT i FROM (VALUES(1),(2)) t(i)
    UNION ALL
    SELECT (i+1)::numeric(10,0) FROM foo WHERE i < 10)
 SELECT * FROM foo;
```
column `i` is CAST to the output type of the UNION ALL due to cockroachdb#62808
in order to support more recursive CTEs without explicit CASTS in
seed (initial) expressions:
https://github.com/cockroachdb/cockroach/blob/0eac48e70abbdd163d4617e50659321b99d678d4/pkg/sql/opt/optbuilder/with.go#L335-L337

Column `i` is assigned column id 3 in `WithScanPrivate.InCols` and
the expression in `recursiveScope.cols[0].scalar` references it as
follows:
```
recursiveScope.cols[0].scalar:
result = {opt.ScalarExpr | *memo.CastExpr}
 Input = {opt.ScalarExpr | *memo.PlusExpr}
  Left = {opt.ScalarExpr | *memo.VariableExpr}
   Col = {opt.ColumnID} 3
   Typ = {*types.T | 0x976b060}
    InternalType = {types.InternalType}
     Family = {types.Family} IntFamily (1)
...
    TypeMeta = {types.UserDefinedTypeMetadata}
   rank = {opt.ScalarRank} 5
  Right = {opt.ScalarExpr | *memo.ConstExpr}
   Value = {tree.Datum | *tree.DInt} 1
```
After the CAST is applied, column id 3 is initialized as:
```
initialScope.cols[0].scalar:
 result = {opt.ScalarExpr | *memo.CastExpr}
 Input = {opt.ScalarExpr | *memo.VariableExpr}
  Col = {opt.ColumnID} 1
  Typ = {*types.T | 0x976b060}
  rank = {opt.ScalarRank} 12
 Typ = {*types.T | 0xc0037f2780}
  InternalType = {types.InternalType}
   Family = {types.Family} DecimalFamily (3)
   Width = {int32} 0
   Precision = {int32} 10
```
During execution, an assertion fails where the input to the `PlusExpr` is
expected to be an integer, but is a decimal:
```
tree.MustBeDInt (datum.go:722) github.com/cockroachdb/cockroach/pkg/sql/sem/tree
eval.(*evaluator).EvalPlusIntOp (binary_op.go:1325) github.com/cockroachdb/cockroach/pkg/sql/sem/eval
tree.(*PlusIntOp).Eval (eval_op_generated.go:761) github.com/cockroachdb/cockroach/pkg/sql/sem/tree
eval.(*evaluator).EvalBinaryExpr (expr.go:120) github.com/cockroachdb/cockroach/pkg/sql/sem/eval
tree.(*BinaryExpr).Eval (eval_expr_generated.go:86) github.com/cockroachdb/cockroach/pkg/sql/sem/tree
eval.(*evaluator).EvalCastExpr (expr.go:180) github.com/cockroachdb/cockroach/pkg/sql/sem/eval
tree.(*CastExpr).Eval (eval_expr_generated.go:96) github.com/cockroachdb/cockroach/pkg/sql/sem/tree
eval.Expr (expr.go:26) github.com/cockroachdb/cockroach/pkg/sql/sem/eval
execinfrapb.(*ExprHelper).Eval (expr.go:248) github.com/cockroachdb/cockroach/pkg/sql/execinfrapb
execinfra.(*ProcOutputHelper).ProcessRow (processorsbase.go:275) github.com/cockroachdb/cockroach/pkg/sql/execinfra
...
```
The left of the Plus is referring to the `IndexedVar` column at ordinal 0:
```
result = {*tree.BinaryExpr | 0xc0022e27c0}
 Operator = {treebin.BinaryOperator}
  Symbol = {treebin.BinaryOperatorSymbol} Plus (3)
  IsExplicitOperator = {bool} false
 Left = {tree.Expr | *tree.IndexedVar}
  Idx = {int} 0
  Used = {bool} true
  col = {tree.NodeFormatter | *colinfo.varFormatter}
  typeAnnotation = {tree.typeAnnotation}
 Right = {tree.Expr | *tree.DInt} 1
 typeAnnotation = {tree.typeAnnotation}
 Op = {*tree.BinOp | 0xc0001817a0}
 ```
which has been CAST as a decimal, as indicated above.

To fully support casting of seed expressions, that may require replacing
all occurences of those expressions in `recursiveScope` with the new
CASTed expressions, and possibly re-doing type checking to catch any
illegal casts, etc.

This issue is solved by reverting cockroachdb#62808 in order to maintain
compatibility with Postgres, which errors out this query.
Relaxing the requirement for explicit CASTs in recursive CTE seed
expressions could possibly be supported in the future, but more work is
required to substitute seed expressions present in the recursive branch
with the implicitly CASTed expressions and make sure type checking is
complete.

Release note (bug fix): This patch fixes recursive CTE expressions which
cause internal errors when explicit CASTs of initial expressions to
output types are missing.