Virtual std module subdirectories (#14040)

# Description

Uses "normal" module `std/<submodule>/mod.nu` instead of renaming the
files (as requested in #13842).

# User-Facing Changes

No user-facing changes other than in `view files` results. Imports
remain the same after this PR.

# Tests + Formatting

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

Also manually confirmed that it does not interfere with nupm, since we
did have a conflict at one point (and it's not possible to test here).

# Performance Tests

## Linux

### Nushell Startup - No config

```nu
bench --pretty -n 200  { <path_to>/nu -c "exit" }
```

| Release | Startup Time |
| --- | --- |
| 0.98.0 | 22ms 730µs 768ns +/- 1ms 515µs 942ns
| This commit | 9ms 312µs 68ns +/- 709µs 378ns
| Yesterday's nightly | 9ms 230µs 953ns +/- 9ms 67µs 689ns

### Nushell Startup - Load full standard library

Measures relative impact of a full `use std *`, which isn't recommended,
but worth tracking.

```nu
bench --pretty -n 200  { <path_to>/nu -c "use std *; exit" }
```

| Release | Startup Time |
| --- | --- |
| 0.98.0 | 23ms 10µs 636ns +/- 1ms 277µs 854ns
| This commit | 26ms 922µs 769ns +/- 562µs 538ns
| Yesterday's nightly | 28ms 133µs 95ns +/- 761µs 943ns
| `deprecated_dirs` removal PR * | 23ms 610µs 333ns +/- 369µs 436ns

\* Current increase is partially due to double-loading `dirs` with
removal warning in older version.

# After Submitting

Still TODO - Update standard library doc

crates/nu-std/std/iter/mod.nu

@@ -0,0 +1,222 @@
+# | Filter Extensions
+# 
+# This module implements extensions to the `filters` commands
+#
+# They are prefixed with `iter` so as to avoid conflicts with 
+# the inbuilt filters
+
+# Returns the first element of the list that matches the
+# closure predicate, `null` otherwise
+#
+# # Invariant
+# > The closure has to be a predicate (returning a bool value)
+# > else `null` is returned
+# > The closure also has to be valid for the types it receives
+# > These will be flagged as errors later as closure annotations
+# > are implemented
+#
+# # Example
+# ```
+# use std ["assert equal" "iter find"]
+#
+# let haystack = ["shell", "abc", "around", "nushell", "std"] 
+#
+# let found = ($haystack | iter find {|it| $it starts-with "a" })
+# let not_found = ($haystack | iter find {|it| $it mod 2 == 0})
+# 
+# assert equal $found "abc"
+# assert equal $not_found null
+# ```
+export def find [ # -> any | null  
+    fn: closure          # the closure used to perform the search 
+] {
+    try {
+       filter $fn | get 0?
+    } catch {
+       null
+    }
+}
+
+# Returns the index of the first element that matches the predicate or
+# -1 if none
+#
+# # Invariant
+# > The closure has to return a bool
+#
+# # Example
+# ```nu
+# use std ["assert equal" "iter find-index"]
+#
+# let res = (
+#     ["iter", "abc", "shell", "around", "nushell", "std"]
+#     | iter find-index {|x| $x starts-with 's'}
+# )
+# assert equal $res 2
+#
+# let is_even = {|x| $x mod 2 == 0}
+# let res = ([3 5 13 91] | iter find-index $is_even)
+# assert equal $res -1
+# ```
+export def find-index [ # -> int
+    fn: closure                # the closure used to perform the search
+] {
+    let matches = (
+        enumerate
+        | each {|it|
+            if (do $fn $it.item) {
+                $it.index
+            }
+        }
+    )
+
+    if ($matches | is-empty) {
+        -1
+    } else {
+        $matches | first
+    }
+}
+
+# Returns a new list with the separator between adjacent
+# items of the original list
+#
+# # Example
+# ```
+# use std ["assert equal" "iter intersperse"]
+#
+# let res = ([1 2 3 4] | iter intersperse 0)
+# assert equal $res [1 0 2 0 3 0 4]
+# ```
+export def intersperse [ # -> list<any>
+    separator: any              # the separator to be used
+] {
+    reduce --fold [] {|it, acc|
+         $acc ++ [$it, $separator]
+    } 
+    | match $in {
+         [] => [],
+         $xs => ($xs | take (($xs | length) - 1 ))
+    }
+}
+
+# Returns a list of intermediate steps performed by `reduce`
+# (`fold`). It takes two arguments, an initial value to seed the
+# initial state and a closure that takes two arguments, the first
+# being the internal state and the second the list element in the
+# current iteration.
+#
+# # Example
+# ```
+# use std ["assert equal" "iter scan"]
+# let scanned = ([1 2 3] | iter scan 0 {|x, y| $x + $y})
+#
+# assert equal $scanned [0, 1, 3, 6]
+#
+# # use the --noinit(-n) flag to remove the initial value from
+# # the final result
+# let scanned = ([1 2 3] | iter scan 0 {|x, y| $x + $y} -n)
+#
+# assert equal $scanned [1, 3, 6]
+# ```
+export def scan [ # -> list<any>
+    init: any            # initial value to seed the initial state
+    fn: closure          # the closure to perform the scan
+    --noinit(-n)         # remove the initial value from the result
+] {                      
+    reduce --fold [$init] {|it, acc|
+        $acc ++ [(do $fn ($acc | last) $it)]
+    }
+    | if $noinit {
+        $in | skip
+    } else {
+        $in
+    }
+}
+
+# Returns a list of values for which the supplied closure does not
+# return `null` or an error. It is equivalent to 
+#     `$in | each $fn | filter $fn`
+#
+# # Example
+# ```nu
+# use std ["assert equal" "iter filter-map"]
+#
+# let res = ([2 5 "4" 7] | iter filter-map {|it| $it ** 2})
+#
+# assert equal $res [4 25 49]
+# ```
+export def filter-map [ # -> list<any>
+    fn: closure                # the closure to apply to the input
+] {
+    each {|$it|
+        try {
+            do $fn $it 
+        } catch {
+            null 
+        }
+    } 
+    | filter {|it|
+        $it != null
+    }
+}
+
+# Maps a closure to each nested structure and flattens the result
+#
+# # Example
+# ```nu
+# use std ["assert equal" "iter flat-map"]
+#
+# let res = (
+#     [[1 2 3] [2 3 4] [5 6 7]] | iter flat-map {|it| $it | math sum}
+# )
+# assert equal $res [6 9 18]
+# ```
+export def flat-map [ # -> list<any>
+    fn: closure              # the closure to map to the nested structures
+] {
+    each {|it| do $fn $it } | flatten
+}
+
+# Zips two structures and applies a closure to each of the zips
+#
+# # Example
+# ```nu
+# use std ["assert equal" "iter iter zip-with"]
+#
+# let res = (
+#     [1 2 3] | iter zip-with [2 3 4] {|a, b| $a + $b }
+# )
+#
+# assert equal $res [3 5 7]
+# ```
+export def zip-with [ # -> list<any>
+    other: any               # the structure to zip with
+    fn: closure              # the closure to apply to the zips
+] {
+    zip $other 
+    | each {|it|
+        reduce {|it, acc| do $fn $acc $it }
+    }
+}
+
+# Zips two lists and returns a record with the first list as headers
+#
+# # Example
+# ```nu
+# use std ["assert equal" "iter iter zip-into-record"]
+#
+# let res = (
+#     [1 2 3] | iter zip-into-record [2 3 4]
+# )
+#
+# assert equal $res [
+#     [1 2 3];
+#     [2 3 4]
+# ]
+# ```
+export def zip-into-record [ # -> table<any>
+    other: list                     # the values to zip with
+] {
+    zip $other
+    | into record
+    | [$in]
+}