feat: support array of any types in Cargo config (#16103)

### What does this PR try to resolve?

This adds the support of array of any types in Cargo config.
The motivation of this is mostly from the proposed `-Zconfig-include`
syntax
(<#7723 (comment)>)

```toml
[[include]]
path = "a.toml"
optional = true
[[include]]
path = "b.toml"
optional = false
```

which before this Cargo only supported array of string.

Some design decisions:

* **Insta-stabilization**: This is insta- stabilizing a extension of
Cargo config. See
<#16103 (comment)>
* **No `CARGO_*` env support added** — Only the `--config` CLI and
file-based configuration start supporting array of any types. `CARGO_*`
config environment still doesn't. The only type you can set through
environment variable are still primitive types. For advanced env usage,
we left it as follow-up to deal with in `-Zadvanced-env`
* **Nothing changed in config merging rule** — Nested complex types in
array won't merge with any other items, as it still respects the current
array merging rule, which appends items.
* `cargo config get` now prints inline array/tables for array of nested
array/tables.

fixes #16111

### How to test and review this PR?

Starting from the fifth commit, those changes are for handling
diagnostic regression, as now `Config::from_toml` accepts any types and
the invalid type error is delayed from the "TOML->ConfigValue"
deserialization to "ConfigValue->Target" Type deserialization. Not sure
if we should split it to a separate PR, but the solution here I admit is
a bit nasty.

Author: epage

src/cargo/ops/cargo_config.rs

@@ -115,6 +115,21 @@ fn print_toml(gctx: &GlobalContext, opts: &GetOptions<'_>, key: &ConfigKey, cv:
         }
         format!(" # {}", def)
     };
+
+    fn cv_to_toml(cv: &CV) -> toml_edit::Value {
+        match cv {
+            CV::String(s, _) => toml_edit::Value::from(s.as_str()),
+            CV::Integer(i, _) => toml_edit::Value::from(*i),
+            CV::Boolean(b, _) => toml_edit::Value::from(*b),
+            CV::List(l, _) => toml_edit::Value::from_iter(l.iter().map(cv_to_toml)),
+            CV::Table(t, _) => toml_edit::Value::from_iter({
+                let mut t: Vec<_> = t.iter().collect();
+                t.sort_by_key(|t| t.0);
+                t.into_iter().map(|(k, v)| (k, cv_to_toml(v)))
+            }),
+        }
+    }
+
     match cv {
         CV::Boolean(val, def) => drop_println!(gctx, "{} = {}{}", key, val, origin(def)),
         CV::Integer(val, def) => drop_println!(gctx, "{} = {}{}", key, val, origin(def)),
@@ -129,31 +144,13 @@ fn print_toml(gctx: &GlobalContext, opts: &GetOptions<'_>, key: &ConfigKey, cv:
             if opts.show_origin {
                 drop_println!(gctx, "{} = [", key);
                 for cv in vals {
-                    let (val, def) = match cv {
-                        CV::String(s, def) => (s.as_str(), def),
-                        // This is actually unreachable until we start supporting list of different types.
-                        // It should be validated already during the deserialization.
-                        v => todo!("support {} type ", v.desc()),
-                    };
-                    drop_println!(
-                        gctx,
-                        "    {}, # {}",
-                        serde::Serialize::serialize(val, toml_edit::ser::ValueSerializer::new())
-                            .unwrap(),
-                        def
-                    );
+                    let val = cv_to_toml(cv);
+                    let def = cv.definition();
+                    drop_println!(gctx, "    {val}, # {def}");
                 }
                 drop_println!(gctx, "]");
             } else {
-                let vals: toml_edit::Array = vals
-                    .iter()
-                    .map(|cv| match cv {
-                        CV::String(s, _) => toml_edit::Value::from(s.as_str()),
-                        // This is actually unreachable until we start supporting list of different types.
-                        // It should be validated already during the deserialization.
-                        v => todo!("support {} type ", v.desc()),
-                    })
-                    .collect();
+                let vals: toml_edit::Array = vals.iter().map(cv_to_toml).collect();
                 drop_println!(gctx, "{} = {}", key, vals);
             }
         }