Move more commands to opaque Record type (#11122)

# Description

Further work towards the goal that we can make `Record`'s field private
and experiment with different internal representations

## Details
- Use inplace record iter in `nu-command/math/utils`
  - Guarantee that existing allocation can be reused
- Use proper record iterators in `path join`
- Remove unnecesary hashmap in `path join`
  - Should minimally reduce the overhead
- Unzip records in `nu-command`
- Refactor `query web` plugin to use record APIs
- Use `Record::into_values` for `values` command
- Use `Record::columns()` in `join` instead.
  - Potential minor pessimisation
  - Not the hot value path
- Use sane `Record` iters in example `Debug` impl
- Avoid layout assumption in `nu-cmd-extra/roll/mod`
  - Potential minor pessimisation
- relegated to `extra`, changing the representation may otherwise break
this op.
- Use record api in `rotate`
- Minor risk that this surfaces some existing invalid behavior as panics
as we now validate column/value lengths
  - `extra` so things are unstable
- Remove unnecessary references in `rotate`
  - Bonus cleanup
# User-Facing Changes
None functional, minor potential differences in runtime. You win some,
you lose some.

# Tests + Formatting
Relying on existing tests

crates/nu-command/src/math/utils.rs

@@ -1,6 +1,8 @@
+use core::slice;
+
 use indexmap::map::IndexMap;
 use nu_protocol::ast::Call;
-use nu_protocol::{IntoPipelineData, PipelineData, Record, ShellError, Span, Value};
+use nu_protocol::{IntoPipelineData, PipelineData, ShellError, Span, Value};
 
 pub fn run_with_function(
     call: &Call,
@@ -81,21 +83,14 @@ pub fn calculate(
             _ => mf(vals, span, name),
         },
         PipelineData::Value(Value::Record { val: record, .. }, ..) => {
-            let new_vals: Result<Vec<Value>, ShellError> = record
-                .vals
-                .into_iter()
-                .map(|val| mf(&[val], span, name))
-                .collect();
-            match new_vals {
-                Ok(vec) => Ok(Value::record(
-                    Record {
-                        cols: record.cols,
-                        vals: vec,
-                    },
-                    span,
-                )),
-                Err(err) => Err(err),
-            }
+            let mut record = record;
+            record
+                .iter_mut()
+                .try_for_each(|(_, val)| -> Result<(), ShellError> {
+                    *val = mf(slice::from_ref(val), span, name)?;
+                    Ok(())
+                })?;
+            Ok(Value::record(record, span))
         }
         PipelineData::Value(Value::Range { val, .. }, ..) => {
             let new_vals: Result<Vec<Value>, ShellError> = val