fix: add defensive checks for CheckOverflow bypass and multiply scale-up

- Validate WideDecimalBinaryExpr output type matches CheckOverflow
  data_type before bypassing the overflow check
- Handle s_out > natural_scale (scale-up) in multiply path for
  consistency with add/subtract

Author: andygrove

native/core/src/execution/planner.rs

@@ -383,12 +383,16 @@ impl PhysicalPlanner {
                 let fail_on_error = expr.fail_on_error;
 
                 // WideDecimalBinaryExpr already handles overflow — skip redundant check
+                // but only if its output type matches CheckOverflow's declared type
                 if child
                     .as_any()
                     .downcast_ref::<WideDecimalBinaryExpr>()
                     .is_some()
                 {
-                    return Ok(child);
+                    let child_type = child.data_type(&input_schema)?;
+                    if child_type == data_type {
+                        return Ok(child);
+                    }
                 }
 
                 // Fuse Cast(Decimal128→Decimal128) + CheckOverflow into single rescale+check

native/spark-expr/src/math_funcs/wide_decimal_binary_expr.rs

@@ -247,17 +247,25 @@ impl PhysicalExpr for WideDecimalBinaryExpr {
             }
             WideDecimalOp::Multiply => {
                 let natural_scale = s1 + s2;
-                let need_rescale = s_out < natural_scale;
-                let rescale_divisor = if need_rescale {
-                    i256_pow10((natural_scale - s_out) as u32)
+                let scale_diff = natural_scale as i16 - s_out as i16;
+                let (need_scale_down, need_scale_up) = (scale_diff > 0, scale_diff < 0);
+                let rescale_divisor = if need_scale_down {
+                    i256_pow10(scale_diff as u32)
+                } else {
+                    i256::ONE
+                };
+                let scale_up_factor = if need_scale_up {
+                    i256_pow10((-scale_diff) as u32)
                 } else {
                     i256::ONE
                 };
 
                 arrow::compute::kernels::arity::try_binary(left, right, |l, r| {
                     let raw = i256::from_i128(l).wrapping_mul(i256::from_i128(r));
-                    let result = if need_rescale {
+                    let result = if need_scale_down {
                         div_round_half_up(raw, rescale_divisor)
+                    } else if need_scale_up {
+                        raw.wrapping_mul(scale_up_factor)
                     } else {
                         raw
                     };