intl: drop def-file pass markers and duplicate guards from emitted headers

The first hardened Crowdin sync exposed two emitter defects. The
template expansion dropped only guards alternated with the strings
pass, so the config-pass wrapper around divergent-key rows - a form
added later - leaked '#ifndef SETTINGS_DEF_CONFIG_PASS' into every
translated header; harmless only because no msg_hash consumer
defines that macro. And a def row's own platform guard repeated an
enclosing template guard verbatim, nesting '#ifdef HAVE_MICROPHONE'
inside itself. Expansion now treats every SETTINGS_DEF marker as
the always-true def-file internal it is, and guard emission drops a
plain condition that is already open; else-branches are never
deduplicated.

All 47 headers re-emitted through the fixed emitter: idempotent,
no pass markers, no duplicated guards, guard-balanced, and the
full-language lookup output is byte-identical against the
sync-landed tree - the cleanup is purely structural. The sync
itself audits clean against its parent: six translation values
changed and six added, nothing removed, no artifacts.

Author: libretroadmin

intl/json2h.py

@@ -65,7 +65,11 @@ def def_to_rows(def_text):
                 # A guard alternated with the strings pass is always true
                 # for string consumers; this expansion mirrors the us.h
                 # consumer, which defines the pass, so drop the pair.
-                if 'SETTINGS_DEF_STRINGS_PASS' in ls:
+                if 'SETTINGS_DEF' in ls:
+                    # Pass markers - strings-pass alternations, the
+                    # config-pass wrapper on divergent-key rows, the
+                    # enum-pass alias shells - are def-file internals,
+                    # always true for string consumers; drop the pair.
                     skip_endif.append(True)
                     i = line_end + 1
                     continue
@@ -380,7 +384,21 @@ def parse_rows_with_guards(text):
 '#pragma warning(disable:4045)\n'
 '#endif\n')
 
+def dedup_guards(g):
+    # A def row's own platform guard can repeat an enclosing template
+    # guard; nested identical plain guards are meaningless, so emit
+    # each open condition once. Else-branches are never deduplicated.
+    out, open_conds = [], set()
+    for cond, in_else in g:
+        if not in_else and cond in open_conds:
+            continue
+        out.append((cond, in_else))
+        open_conds.add(cond)
+    return tuple(out)
+
 def emit_guard_transition(out, prev, cur):
+    prev = dedup_guards(prev)
+    cur = dedup_guards(cur)
     if prev == cur:
         return
     for _ in prev: