Allow variables in columns of table literals (nushell#16669)

Fixes nushell#15333 

This should bring things more in line with how records work. Turns out
it was already be parsed properly, it was just the type check code
causing problems. If a column name isn't a literal then we just don't
add that column to type at parse-time.

+3 tests

## Release notes summary - What our users need to know
### Table literal columns support variables
Table literals can now have variables in the column names list. For
example, this is now allowed:
```nushell
let column_name = 'column0'
[[    $column_name    column1  ];
 [    foo             bar      ]
 [    baz             car      ]
 [    far             fit      ]]
# => ╭───┬─────────┬─────────╮
# => │ # │ column0 │ column1 │
# => ├───┼─────────┼─────────┤
# => │ 0 │ foo     │ bar     │
# => │ 1 │ baz     │ car     │
# => │ 2 │ far     │ fit     │
# => ╰───┴─────────┴─────────╯
```

<details>
<summary>ANSI code block</summary>

```ansi
�[38;5;6m> �[1;36mlet �[0m�[35mcolumn_name �[39m= �[32m'column0'�[0m
�[1;34m[[    �[0m�[35m$column_name    �[32mcolumn1  �[1;34m];�[0m
 �[1;34m[    �[0m�[32mfoo             bar      �[1;34m]�[0m
 �[1;34m[    �[0m�[32mbaz             car      �[1;34m]�[0m
 �[1;34m[    �[0m�[32mfar             fit      �[1;34m]]�[0m
�[39m╭───┬─────────┬─────────╮�[0m
�[39m│ �[1;32m# �[0m�[39m│ �[1;32mcolumn0 �[0m�[39m│ �[1;32mcolumn1 �[0m�[39m│�[0m
�[39m├───┼─────────┼─────────┤�[0m
�[39m│ �[1;32m0 �[0m�[39m│ foo     │ bar     │�[0m
�[39m│ �[1;32m1 �[0m�[39m│ baz     │ car     │�[0m
�[39m│ �[1;32m2 �[0m�[39m│ far     │ fit     │�[0m
�[39m╰───┴─────────┴─────────╯�[0m
```

</details>

Author: 132ikl

crates/nu-parser/src/parser.rs

@@ -4806,12 +4806,13 @@ fn table_type(head: &[Expression], rows: &[Vec<Expression>]) -> (Type, Vec<Parse
     let mut ty = head
         .iter()
         .rev()
-        .map(|expr| {
-            if let Some(str) = expr.as_string() {
-                str
-            } else {
+        // Include only known column names in type
+        .filter_map(|expr| {
+            if !Type::String.is_subtype_of(&expr.ty) {
                 errors.push(mk_error(expr.span));
-                String::from("{ column }")
+                None
+            } else {
+                expr.as_string()
             }
         })
         .map(|title| (title, mk_ty()))

tests/repl/test_parser.rs

@@ -1051,3 +1051,39 @@ fn redefine_def_should_not_panic() -> TestResult {
         "Missing required positional argument.",
     )
 }
+
+#[test]
+fn table_literal_column_var() -> TestResult {
+    run_test(
+        r#"
+            let column_name = 'column0'
+            let tbl = [[ $column_name column1 ]; [ foo bar ] [ baz car ] [ far fit ]]
+            $tbl.column0.0
+        "#,
+        "foo",
+    )
+}
+
+#[test]
+fn table_literal_column_var_parse_err() -> TestResult {
+    fail_test(
+        r#"
+            let column_name = {a: 123}
+            let tbl = [[ $column_name column1 ]; [ foo bar ] [ baz car ] [ far fit ]]
+            $tbl.column0.0
+        "#,
+        "must be a string",
+    )
+}
+
+#[test]
+fn table_literal_column_var_shell_err() -> TestResult {
+    fail_test(
+        r#"
+            let column_name = echo {a: 123}
+            let tbl = [[ $column_name column1 ]; [ foo bar ] [ baz car ] [ far fit ]]
+            $tbl.column0.0
+        "#,
+        "can't convert",
+    )
+}