Remove python-like string multiplication (#10293)

# Description
Currently we support "multiplication" of strings, resulting in a terse
way to repeat a particular string.
This can have unintended side effects when dealing with mixed data (e.g.
after parsing data that is not all numbers).
Furthermore as we frequently fall-back to strings while parsing source
code, this introduced a runaway edge case in const evaluation (#10212)

Work for #10233

## Details
- Remove python-like string multiplication.
- Workaround for indentation
  - This should probably be addressed with a purpose built command
- Remove special const-eval error test

# User-Facing Changes
**Major breaking change!**
`"string" * 42` will stop working. (This was used for example in the
stdlib)

We should bless a good alternative before landing this

---------

Co-authored-by: JT <547158+jntrnr@users.noreply.github.com>

crates/nu-protocol/src/eval_const.rs

@@ -415,16 +415,6 @@ pub fn eval_constant(
                     }
                 }
                 Operator::Math(math) => {
-                    match (&math, &lhs.expr, &rhs.expr) {
-                        // Multiple may generate super long string
-                        // and stop the whole shell while highlighting
-                        // e.g. '2 ** 60 * a'
-                        (Math::Multiply, Expr::String(..), _)
-                        | (Math::Multiply, _, Expr::String(..)) => {
-                            return Err(ShellError::NotAConstant(expr.span))
-                        }
-                        _ => {}
-                    }
                     let lhs = eval_constant(working_set, lhs)?;
                     let rhs = eval_constant(working_set, rhs)?;
 

crates/nu-protocol/src/value/mod.rs

@@ -2649,20 +2649,6 @@ impl Value {
             (Value::CustomValue { val: lhs, .. }, rhs) => {
                 lhs.operation(self.span(), Operator::Math(Math::Multiply), op, rhs)
             }
-            (Value::Int { val: lhs, .. }, Value::String { val: rhs, .. }) => {
-                let mut res = String::new();
-                for _ in 0..*lhs {
-                    res.push_str(rhs)
-                }
-                Ok(Value::string(res, span))
-            }
-            (Value::String { val: lhs, .. }, Value::Int { val: rhs, .. }) => {
-                let mut res = String::new();
-                for _ in 0..*rhs {
-                    res.push_str(lhs)
-                }
-                Ok(Value::string(res, span))
-            }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
                 lhs_ty: self.get_type().to_string(),