refactor(tools): group the sixty scripts by what they talk to

One directory with sixty scripts stopped being navigable, and the grouping is also the sandbox boundary:

  Tools/unreal/    commandlets and the two map builders, with ue_common.py and ue_placement.py as the
                   shared imports (they need the engine)
  Tools/blender/   builders, exporters, the FBX preset, the MPFB character pipeline, blender_screenshots
                   (they need the Blender Flatpak)
  Tools/review/    the visual loop: render_screenshots.sh, judge_screenshot.py, hero_compare.py,
                   build_comparison_md.py, e2e_asset_check.py, hero_iterate.sh, visual_loop.py,
                   visual_targets.json
  Tools/gen/       image and texture generation: the ComfyUI driver, deterministic texture writers,
                   reference fetching
  Tools/input/     OS-level input injection
  root             _common.py, check-lfs.sh, addon_compat_probe.py, sibling_asset_audit.py, tests/

Every moved script now resolves the repository root as ../.. and puts the tools root plus its siblings on
sys.path, so 'import ue_common' still works from unreal/. The test suite bootstrap does the same for the five
folders. render_screenshots.sh takes the folder as a third argument to run_cmdlet, and the e2e driver,
hero_iterate.sh and the comparison generator were repointed.

51 README rows now link to their new location, the README gains a Layout section naming each folder's
sandbox, and the architecture notes and Blender README follow the moves.

Verified: 108 tests pass, prettier is clean, judge_screenshot.py and hero_compare.py run from their new
homes, and the e2e run was aborted mid-way (it had been rebuilding an empty DemoMap for 15 minutes) and is
being rerun against the new layout.

Tools/unreal/ue_import_facade_kit.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Import the façade module kit into Unreal: /Game/Hollywood/Kit/*.
+
+Pairs with `Tools/blender/facade_kit_build.py`. Each piece is imported as its own static
+mesh at the module's origin (bottom-front centre), so a building can place a
+piece by bay index and storey index with a single offset.
+
+    UnrealEditor-Cmd <uproject> -run=pythonscript \
+        -script=Tools/unreal/ue_import_facade_kit.py -nullrhi -unattended -nopause -stdout
+
+Result file: /tmp/gigline/kit-import.txt (the commandlet swallows print()).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import unreal
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import ue_common  # noqa: E402
+
+SRC = "/tmp/gigline/kit"
+DEST = "/Game/Hollywood/Kit"
+RESULT = "/tmp/gigline/kit-import.txt"
+
+lines: list[str] = []
+
+
+def log(message: str) -> None:
+    lines.append(message)
+    print(message)
+
+
+def main() -> None:
+    if not os.path.isdir(SRC):
+        log(f"MISSING source directory {SRC} — run Tools/blender/facade_kit_build.py first")
+        return
+    files = sorted(f for f in os.listdir(SRC) if f.lower().endswith(".fbx"))
+    if not files:
+        log(f"no FBX files in {SRC}")
+        return
+
+    # Drop kit assets that the current build no longer produces (the pieces were
+    # renamed to follow the SM_ convention), so the folder cannot accumulate two
+    # generations of the same piece.
+    expected = {os.path.splitext(f)[0] for f in files}
+    for existing in unreal.EditorAssetLibrary.list_assets(DEST, recursive=False):
+        name = existing.split("/")[-1].split(".")[0]
+        if name not in expected:
+            unreal.EditorAssetLibrary.delete_asset(f"{DEST}/{name}")
+            log(f"removed stale kit asset {name}")
+
+    for filename in files:
+        asset_name = os.path.splitext(filename)[0]
+        task = unreal.AssetImportTask()
+        task.filename = os.path.join(SRC, filename)
+        task.destination_path = DEST
+        task.destination_name = asset_name
+        task.automated = True
+        task.save = True
+        task.replace_existing = True
+        ui = unreal.FbxImportUI()
+        ui.import_mesh = True
+        ui.import_materials = True
+        ui.import_textures = False
+        ui.import_as_skeletal = False
+        smd = ui.static_mesh_import_data
+        smd.import_uniform_scale = 1.0
+        smd.combine_meshes = True
+        smd.convert_scene_unit = False
+        smd.force_front_x_axis = False
+        smd.normal_import_method = unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS
+        # Kit pieces are thin boxes and panes: complex-as-simple keeps the
+        # collision on the real faces instead of a fat convex hull that would
+        # fence off the shopfront glazing.
+        smd.auto_generate_collision = False
+        task.options = ui
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+
+        mesh = unreal.EditorAssetLibrary.load_asset(f"{DEST}/{asset_name}")
+        if mesh is None:
+            log(f"{asset_name}: IMPORT FAILED")
+            continue
+        # The FBX import also creates an M_Kit_* material per piece. The demo
+        # assigns real site materials at assembly time, so those are clutter.
+        for slot in mesh.get_editor_property("static_materials"):
+            mat = slot.get_editor_property("material_interface")
+            if mat and mat.get_name().startswith("M_Kit_"):
+                unreal.EditorAssetLibrary.delete_asset(mat.get_path_name().split(".")[0])
+        unreal.GigLineAssetTools.set_complex_collision_as_simple(mesh, True)
+        unreal.EditorAssetLibrary.save_loaded_asset(mesh)
+        box = mesh.get_bounding_box()
+        mn, mx = box.min, box.max
+        log(f"{asset_name:20} size=({mx.x - mn.x:6.1f}, {mx.y - mn.y:6.1f}, "
+            f"{mx.z - mn.z:6.1f}) cm  min=({mn.x:6.1f}, {mn.y:6.1f}, {mn.z:6.1f}) "
+            f"collision={unreal.GigLineAssetTools.get_collision_complexity(mesh)}")
+
+    log(f"imported {len(files)} kit piece(s) into {DEST}")
+
+
+try:
+    main()
+except Exception as exc:  # noqa: BLE001 - surface the failure in the result file
+    import traceback
+    log(f"FAILED: {type(exc).__name__}: {exc}")
+    log(traceback.format_exc())
+
+os.makedirs(os.path.dirname(RESULT), exist_ok=True)
+with open(RESULT, "w", encoding="utf-8") as handle:
+    handle.write("\n".join(lines) + "\n")