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/plan_track_renderer.cppm

@@ -0,0 +1,51 @@
+/*
+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/.
+*/
+module;
+#include <cstdint>
+#include <vector>
+
+export module eu07.editor.plan_track_renderer;
+export import eu07.editor.plan_scene;
+
+export {
+
+namespace editor::plan::render {
+
+/// One sampled centreline element of a solved niweleta, tagged with its logical
+/// origin so a UI can colour, label and hit-test it. Rendering-neutral: it holds
+/// the track axis only — no rails, no styling. This is the contract the solver
+/// hands to a renderer.
+struct CentrelineElement {
+    ElementKind kind{ElementKind::Straight};
+    std::vector<Point> points;    ///< sampled axis in CRS metres
+    std::uint32_t element_id{0};  ///< the authored element this came from
+    std::uint32_t owner_id{0};    ///< the track or turnout it belongs to
+    bool from_turnout{false};     ///< true when owner_id names a turnout
+    double length{0.0};           ///< element length (metres)
+    double radius_start{0.0};     ///< 0 == infinite (straight / clothoid open end)
+    double radius_end{0.0};
+};
+
+/// Interface every renderer must satisfy.
+///
+/// The solver emits rendering-neutral CentrelineElements; a renderer turns each
+/// into concrete drawable geometry (a single axis line, two rails, an SVG path,
+/// ...). A renderer holds NO business logic — it only shapes presentation, so
+/// swapping renderers never changes what geometry the solver computed.
+class TrackRenderer {
+public:
+    virtual ~TrackRenderer() = default;
+
+    /// Called once per centreline element, in plan order.
+    virtual void add(const CentrelineElement& element) = 0;
+};
+
+}  // namespace editor::plan::render
+
+}  // export