Harden YAML nested map shape, add direct STL includes

Codex Round 4 cross-review:
- ConventionChecker.cpp: nested input/output/instance prefix access
  threw YAML::BadSubscript before the inner try when the parent node
  was a scalar instead of a map. Now the parent shape is validated
  before child indexing, with the whole nested access guarded.
- StyleSyntaxScanner.cpp: added direct <vector> and <unordered_map>
  includes; previously transitively available via slang headers but
  a portability trap on stricter libc++.

Tests extended: malformed-parent-shape YAML now exercised.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: babyworm

src/ConventionChecker.cpp

@@ -80,29 +80,52 @@ ConventionRules loadConventionRules(const std::string& yamlPath) {
         rules.inputPrefix = *value;
     else if (auto value = getString(root, "inputPrefix"); value)
         rules.inputPrefix = *value;
-    else if (root["input"] && root["input"]["prefix"]) {
+    else {
+        // Codex Round 4 cross-review: guard the parent-shape check too.
+        // If `input` is a scalar (e.g. `input: scalar_not_a_map`) then
+        // `root["input"]["prefix"]` throws YAML::BadSubscript before the
+        // inner try fires.  Wrap the entire parent+child access so a
+        // non-map parent node is silently ignored.
         try {
-            rules.inputPrefix = root["input"]["prefix"].as<std::string>();
+            if (auto in = root["input"]; in && in.IsMap()) {
+                if (auto p = in["prefix"]; p && p.IsScalar()) {
+                    try {
+                        rules.inputPrefix = p.as<std::string>();
+                    } catch (const YAML::Exception&) {}
+                }
+            }
         } catch (const YAML::Exception&) {}
     }
 
     if (auto value = getString(root, "output_prefix"); value)
         rules.outputPrefix = *value;
     else if (auto value = getString(root, "outputPrefix"); value)
         rules.outputPrefix = *value;
-    else if (root["output"] && root["output"]["prefix"]) {
+    else {
         try {
-            rules.outputPrefix = root["output"]["prefix"].as<std::string>();
+            if (auto out = root["output"]; out && out.IsMap()) {
+                if (auto p = out["prefix"]; p && p.IsScalar()) {
+                    try {
+                        rules.outputPrefix = p.as<std::string>();
+                    } catch (const YAML::Exception&) {}
+                }
+            }
         } catch (const YAML::Exception&) {}
     }
 
     if (auto value = getString(root, "instance_prefix"); value)
         rules.instancePrefix = *value;
     else if (auto value = getString(root, "instancePrefix"); value)
         rules.instancePrefix = *value;
-    else if (root["instance"] && root["instance"]["prefix"]) {
+    else {
         try {
-            rules.instancePrefix = root["instance"]["prefix"].as<std::string>();
+            if (auto inst = root["instance"]; inst && inst.IsMap()) {
+                if (auto p = inst["prefix"]; p && p.IsScalar()) {
+                    try {
+                        rules.instancePrefix = p.as<std::string>();
+                    } catch (const YAML::Exception&) {}
+                }
+            }
         } catch (const YAML::Exception&) {}
     }
 

src/StyleSyntaxScanner.cpp

@@ -10,7 +10,9 @@
 
 #include <string>
 #include <string_view>
+#include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 namespace connect {
 

tests/test_convention_checker.cpp

@@ -203,6 +203,35 @@ TEST_CASE("ConventionChecker: malformed nested prefix field keeps default and do
     std::remove(yamlPath);
 }
 
+TEST_CASE("ConventionChecker: malformed parent-shape YAML keeps default and does not throw") {
+    // Codex Round 4 cross-review: if a parent node like `input` is a
+    // scalar rather than a map (e.g. `input: scalar_not_a_map`), then
+    // `root["input"]["prefix"]` throws YAML::BadSubscript before the
+    // inner try/catch fires.  The outer try added in R4 must absorb this
+    // so load completes and the field keeps its struct default.
+    const char* yamlPath = "test_convention_parent_shape.yaml";
+    {
+        std::ofstream ofs(yamlPath);
+        REQUIRE(ofs.good());
+        ofs << "input: scalar_not_a_map\n";    // parent is scalar, not map
+        ofs << "output: scalar_not_a_map\n";   // same for output
+        ofs << "instance: scalar_not_a_map\n"; // same for instance
+        ofs << "output_prefix: out_\n";        // valid flat key after bad parents
+    }
+
+    ConventionRules rules;
+    REQUIRE_NOTHROW(rules = loadConventionRules(yamlPath));
+
+    // All nested-prefix fields keep struct defaults (no throw, no crash).
+    ConventionRules defaultRules;
+    CHECK(rules.inputPrefix == defaultRules.inputPrefix);
+    CHECK(rules.instancePrefix == defaultRules.instancePrefix);
+    // The valid flat key after the bad parents must still apply.
+    CHECK(rules.outputPrefix == "out_");
+
+    std::remove(yamlPath);
+}
+
 TEST_CASE("ConventionChecker: bad scalar does not skip later valid keys") {
     // Codex Round 2 cross-review: the previous whole-block try/catch
     // aborted on the first YAML::BadConversion, silently dropping any