feat: read a search list as one need

A core that loads the first of several names (yabause: saturn_bios.bin,
sega_101.bin, mpr-17933.bin) needs one of them. Profiles wrote this as
required on the first name and optional on the others, so verify and
the gap report called saturn_bios.bin a missing required file while
sega_101.bin was held, and a set held only through a name marked
optional read as a need met by an optional file.

Model: an explicit group on the file entry, mirroring the platform
field. priority was not reused: it is a rank, read by slot.py, region.py
and truth.py inside a (system, region) slot, and that slot is not the
set. px68k-sdl ranks its IPL list and its font list each from 1 in one
system, pom2 ranks one list per machine model, DuckStation ranks 105
images across every region and takes any of them. A rank cannot say
where one list ends. priority stays the order inside a group.

Readers, through alternatives.settle_sets:
- verify --emulator and the emulator pack: a held member fills the
  set, the others leave the report, a set nobody holds is one gap
  under its first member naming the others.
- find_undeclared_files (verify platform, core complement of packs and
  manifests): same rule, a platform declaration or launcher counts as
  answering the set.
- cross_reference: excused members are set aside as other versions.
- slot.py: ranks compare members of one set only.
- archive members: a required set inside an archive is met by one.
- truth: a member gives no requirement of its own, one_of and
  one_of_required carry the set, and the exporters and the diff leave
  such a line's required as the platform wrote it.
- validate_schemas: members of a group share required.

scripts/exporter/baseline.py

@@ -264,6 +264,8 @@ class NativeFile:
             return bool(self.truth["required"])
         if self.platform is not None and self.platform.get("required") is not None:
             return bool(self.platform["required"])
+        if self.truth is not None and self.truth.get("one_of_required") is not None:
+            return bool(self.truth["one_of_required"])
         return True
 
     @property
@@ -645,10 +647,15 @@ def build_native_model(
                         matched.filled.append(field_name)
                 t_req = truth_entry.get("required")
                 p_req = (matched.platform or {}).get("required")
+                # A file a core takes as one of a set has no requirement of
+                # its own: a platform line cannot say "one of these", so
+                # truth leaves its value as written rather than claim
+                # every member optional or every member needed.
                 if (
                     t_req is not None
                     and p_req is not None
                     and bool(t_req) != bool(p_req)
+                    and not (truth_entry.get("one_of_required") and not t_req)
                 ):
                     matched.corrections.append("required")
                     report.required_corrected.append(

scripts/exporter/recalbox_exporter.py

@@ -189,16 +189,21 @@ class Exporter(BaseExporter):
         } - {""}
         readers: set[str] = set()
         requirers: set[str] = set()
+        set_readers: set[str] = set()
         for entry in entries:
             cores = set(entry.get("_cores") or ()) & named
             readers |= cores
+            if entry.get("one_of_required"):
+                set_readers |= cores & set(entry.get("one_of") or ())
             required_by = entry.get("_required_by")
             if required_by is None:
                 if entry.get("required") is not False:
                     requirers |= cores
             else:
                 requirers |= cores & set(required_by)
-        if not readers:
+        # A core that needs one file of a set needs none of them on its own,
+        # which a mandatory flag cannot say: the line keeps its value.
+        if not readers or (not requirers and set_readers):
             if fe.platform is not None and fe.platform.get("required") is not None:
                 return bool(fe.platform["required"])
             return fe.required