feat(track): all of the unevenness in one attribute, with values for each path of a switch

Usage, before endtrack, in mm, 0-100, separated by semicolons with no
spaces:

  a plain track:  uneven value;up;side;cross;dip
  a switch:       uneven p1-p2;p3-p4;up p1-p2;side p1-p2;up p3-p4;side p3-p4

  uneven 18           the value alone
  uneven 18;;;25;6    with its own cross level and dip at the joints
  uneven 0;;30        sideways alone
  uneven 14;35        a switch, 14 on the straight path, 35 on the diverging

What's left out takes the first number, the dip goes by the up and down
one, and a path p3-p4 with no numbers of its own takes those of p1-p2.
This replaces unevenup, unevenside, unevencross and jointdip. The fields
in the editor stay, track panel, section Ride and sound.

At the end they share, the paths of a switch keep to the lower value, and
each comes to its own value along the way. Joined switches take the lowest
of the same path, a path joined to another path the lower of the two, and
a plain track comes to the value of the path it meets. See
track_uneven_doc.md.

world/TrackUneven.h

@@ -11,7 +11,10 @@ http://mozilla.org/MPL/2.0/.
 
 #include <algorithm>
 #include <array>
+#include <charconv>
 #include <cmath>
+#include <sstream>
+#include <string>
 #include <glm/glm.hpp>
 #include <glm/gtc/constants.hpp>
 
@@ -34,6 +37,11 @@ struct amounts {
     double cross { 0.0 };
 };
 
+inline amounts least( amounts const &Left, amounts const &Right ) {
+
+    return { std::min( Left.up, Right.up ), std::min( Left.side, Right.side ), std::min( Left.cross, Right.cross ) };
+}
+
 struct wave {
     double x;
     double z;
@@ -41,6 +49,44 @@ struct wave {
     double share;
 };
 
+// the numbers of an entry like "uneven 14;35", negative where left out
+template <std::size_t Count>
+std::array<float, Count> read_fields( std::string const &Text ) {
+
+    std::array<float, Count> result;
+    result.fill( -1.f );
+    std::size_t start { 0 };
+    for( std::size_t index = 0; index < Count && start < Text.size(); ++index ) {
+        auto const end { std::min( Text.find( ';', start ), Text.size() ) };
+        auto value { 0.f };
+        if( end > start && std::from_chars( Text.data() + start, Text.data() + end, value ).ec == std::errc {} ) {
+            result[ index ] = std::clamp( value, 0.f, most );
+        }
+        start = end + 1;
+    }
+    return result;
+}
+
+// and back, with the ones left out at the end dropped
+template <std::size_t Count>
+std::string write_fields( std::array<float, Count> const &Fields ) {
+
+    auto count { Count };
+    while( count > 1 && Fields[ count - 1 ] < 0.f ) {
+        --count;
+    }
+    std::ostringstream text;
+    for( std::size_t index = 0; index < count; ++index ) {
+        if( index > 0 ) {
+            text << ';';
+        }
+        if( Fields[ index ] >= 0.f ) {
+            text << Fields[ index ];
+        }
+    }
+    return text.str();
+}
+
 template <std::size_t Count>
 using wave_set = std::array<wave, Count>;