Editor: fold the plan library into the tree as modules, drop its own name

The track layout library came in as a subproject of its own -- its own
CMakeLists, its own install and export rules, its own include tree -- which only
made the build harder to follow now that everything else is a module. It is part
of the editor, so it lives where the editor lives.

- editor/plan_*.cppm / plan_*.cpp: the fifteen interface units and twelve
  implementation units, flat in editor/ beside editorTerrain and orthophoto, with
  the plan_ prefix keeping them clear of what was already there (editor/turnouts
  is the preset catalogue, so the geometry is plan_turnout_geometry).
- modules are named eu07.editor.plan_*, like every other module in the tree.
- namespaces move under the editor's own: editor::plan, editor::plan::geometry,
  ::io, ::render. The library's old name is gone from the sources and the docs.
- every moved file carries the MPL header the rest of the tree carries; it had
  none. version.hpp went with the subproject: macros only, and unused.
- the umbrella header is dropped -- nothing imported it.
- the unit tests survive the fold: editor/tests, behind EU07_EDITOR_PLAN_TESTS
  (off by default), compiles the interfaces a second time into a small library of
  its own, because a test can only import modules from a target it links and
  linking the game would drag the whole simulator in. The code under test needs
  nothing but a compiler. 7/7 pass.
- a switch may now be written with two dashes as well: --editor beside -editor.

Builds with clang 22 (-DWITH_BETTER_RENDERER=OFF); -editor and --editor both come
up in the editor on empty ground.

editor/tests/check.hpp

@@ -0,0 +1,59 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+#pragma once
+
+// A tiny zero-dependency check framework so the test suite needs nothing but a
+// C++20 compiler. Each test executable returns 0 on success, 1 on any failure,
+// which is exactly what CTest interprets as pass/fail.
+
+#include <cstdio>
+
+namespace plantest {
+inline int checks = 0;
+inline int failures = 0;
+}  // namespace plantest
+
+// Variadic so that brace-init lists with commas, e.g. CHECK(Point{1, 2} == ...),
+// are passed through as a single condition instead of several macro arguments.
+#define CHECK(...)                                                           \
+    do {                                                                     \
+        ++::plantest::checks;                                                \
+        if (!(__VA_ARGS__)) {                                                \
+            ++::plantest::failures;                                          \
+            std::printf("  [FAIL] %s:%d  CHECK(%s)\n", __FILE__, __LINE__,   \
+                        #__VA_ARGS__);                                       \
+        }                                                                    \
+    } while (0)
+
+#define CHECK_THROWS(...)                                                    \
+    do {                                                                     \
+        ++::plantest::checks;                                                \
+        bool threw = false;                                                  \
+        try {                                                                \
+            (void)(__VA_ARGS__);                                             \
+        } catch (...) {                                                      \
+            threw = true;                                                    \
+        }                                                                    \
+        if (!threw) {                                                        \
+            ++::plantest::failures;                                          \
+            std::printf("  [FAIL] %s:%d  CHECK_THROWS(%s)\n", __FILE__,      \
+                        __LINE__, #__VA_ARGS__);                             \
+        }                                                                    \
+    } while (0)
+
+#define RUN(fn)                              \
+    do {                                     \
+        std::printf("[RUN ] %s\n", #fn);     \
+        fn();                                \
+    } while (0)
+
+#define REPORT()                                                             \
+    (std::printf("\n%d checks, %d failures\n", ::plantest::checks,           \
+                 ::plantest::failures),                                      \
+     ::plantest::failures == 0 ? 0 : 1)