Fix Linux game detection: search every Steam install, and don't dereference a null

[IrPgFKS0]

Three separate reasons LegitimacyCheck() can fail to find BeamNG on Linux, all in the __linux__
branch of src/Security/BeamNG.cpp. Each is visible by reading the code; the second and third are
also demonstrable.

1. The search stops at the first Steam install

for (const auto& path : steamappsCommonPaths) {
    if (std::filesystem::exists(steamappsPath)) {
        steamappsFolderFound = true;
        libraryFoldersPath = steamappsPath / "libraryfolders.vdf";
        if (std::filesystem::exists(libraryFoldersPath)) {
            libraryFoldersFound = true;
            break;            // <-- first vdf wins, permanently
        }
    }
}

It breaks as soon as it finds a steamapps folder that merely has a libraryfolders.vdf — not one
that actually lists the game. A machine with more than one Steam install (a native one plus Flatpak
is common) only ever gets the first examined; if the game is registered in the other, detection
fails even though everything is installed correctly.

Now every candidate that exists is searched, stopping when the game is actually found.

2. Null dereference on a library with no apps block

(folderInfo.second->childs["apps"]->attribs).contains("284160")

childs is unordered_map<string, shared_ptr<basic_object>>, so operator[] on a missing key
value-initialises a null shared_ptr, inserts it, and the -> dereferences null. A library
folder entry with no games installed has exactly that shape.

I checked this against the vendored vdf_parser.hpp rather than assuming. Parsing:

"libraryfolders"
{
    "0" { "path" "/home/u/.local/share/Steam"  "label" "" }
    "1" { "path" "/mnt/games/SteamLibrary"  "apps" { "284160" "12345678" } }
}

childs["apps"] yields nullptr for entry "0". With find() + a null check the entry is
skipped and the game is correctly found in entry "1".

3. A detection failure is reported, then ignored

All three failure paths return with GameDir empty, and main() continues straight into
PreGame(GetGameDir()) → CheckVer() → std::filesystem::file_size() on a path that does not
exist. That is why the report in #251 shows two errors:

[ERROR] The game directory was not found.
[ERROR] Exception in main(): filesystem error: cannot get file size: No such file or directory [integrity.json]

The second is only a consequence of the first, but it is the one that looks like the bug. These now
throw with a message saying what was searched for. LegitimacyCheck() is already called inside
a try/catch in main() that logs and rethrows — this change simply makes that handler
reachable; it could not fire for this path before.

Also

Two Steam locations that were missing from the candidate list:

• ~/.local/share/Steam/steamapps — a native install where the ~/.steam symlinks are absent
• ~/.var/app/com.valvesoftware.Steam/.local/share/Steam/steamapps — Flatpak's real data
  directory, rather than only the .steam/root symlink inside the sandbox

Scope

This deliberately does not touch case-sensitive path resolution. That is what #259 addresses,
and these changes compose with it rather than conflicting — if a library path's casing does not
match the disk, #259's resolver is still what is needed.

Refs #251.

Testing

Verified the new library-scanning logic against the real vdf_parser.hpp: an entry without an
apps block is skipped rather than dereferenced, a vdf that does not list 284160 yields nothing
so the outer loop continues, and the upstream expression is confirmed to produce the null described
above.

I was not able to run a full Linux build locally (my container toolchain is broken at the
moment), so the complete translation unit is unverified on GCC — hence draft. The change is
confined to the __linux__ branch and uses no API the surrounding code does not already use
(debug(std::string) appears a few lines above; .contains is already used on attribs).

---

Transparency: this fix came out of debugging a LAN-only fork of the launcher, and was written with
AI assistance and reviewed by me. I am not making the template's self-authorship declaration, and
I am filing it as a draft so maintainers can decide how they want to treat it. Happy to rework,
split, or close it.

[IrPgFKS0]

Update: I was able to build this on Linux after all (my container toolchain is working again), so the caveat in the description about the full translation unit being unverified on GCC no longer applies — it compiles clean, and the resulting binary contains the new code paths.

Still happy to rework or split this however suits you.