multiplayer: stream the authoritative state, and let a client walk into a cab

First live test showed three things wrong at once.

A client could not take a vehicle. Walking up to a locomotive and pressing the
enter-vehicle key posts entervehicle, which stage 4 classed as a world-wide
command and refused outright ("reserved for the session host"), so the client
never got a cab and every later control command died locally for want of one.
Walking into a cab is a request for a seat, not a world command: the authority
now turns it into a crew claim, for the host through the same path as for a
remote peer, and answers it the way the lobby button is answered.

Nothing but commands was ever replicated. The server sent dt and the commands
it ran, and the client simulated the rest for itself - so a pantograph the host
raised before the client joined, the contents of the memory cells the signalling
reads, brake pressures and switch positions simply never crossed the wire. The
server now streams the authoritative state a few times a second: whatever has
changed since the last one, and the whole of it every so often so a peer heals
from anything it missed. The snapshot carries the vehicle's inputs - line
breaker, battery, converter and compressor permits, pantograph valves, cab,
lights, doors - and lets the receiving peer derive the rest, plus the memory
cells and the switches.

Desync detection demanded that two state digests be equal, on a design where
the client deliberately runs its own physics. They never can be, so it reported
a desync permanently and asked for a resync every five seconds forever, which
fixed nothing because the next step disagreed again. The digest is a log line
now; what is measured instead is how far out of place the routine correction
found us, and a full resync is only asked for when even that is not catching up.

Also: a consist is put back on the rails as a whole or not at all. Correcting
one vehicle while its neighbour stayed put is what was stretching couplers
until they tore - the last test moved six vehicles out of eight, every time.

And the lobby window collapsed to nothing, because its size_max was left at the
-1 default while size_min was set, so imgui was handed a maximum smaller than
the minimum.

network/snapshot.h

@@ -16,27 +16,54 @@ namespace network
 {
 
 // layout of the snapshot container. a reader refuses a blob it does not understand
-constexpr uint32_t SNAPSHOT_VERSION = 1;
+constexpr uint32_t SNAPSHOT_VERSION = 2;
 
 // the sections a snapshot is built from. a reader skips over any id it does not know,
 // which is what makes the format extensible: a peer built before a section existed can
 // still read a newer snapshot and simply ignores what it has no use for
 enum snapshot_chunk : uint16_t
 {
-	// tick, clock, weather and the state of the random engine
+	// tick, clock, weather and (in a full snapshot) the state of the random engine
 	SNAPSHOT_SESSION = 1,
-	// where every vehicle is and what its controls and brakes are doing
+	// where every vehicle is, what its controls and appliances are set to, and what its
+	// brakes are doing
 	SNAPSHOT_VEHICLES = 2,
 	// who is working which vehicle
-	SNAPSHOT_CREWS = 3
-	// candidates for the next versions: switches, memcells, the event queue, signals
+	SNAPSHOT_CREWS = 3,
+	// contents of the memory cells - this is what signalling reads
+	SNAPSHOT_MEMCELLS = 4,
+	// which way the switches are thrown
+	SNAPSHOT_SWITCHES = 5
 };
 
-// packs the current state of the world. only ever called on the authority
-std::string take_snapshot();
+// what a peer is meant to do with the blob it received
+enum class snapshot_mode
+{
+	// the peer is coming in cold and takes the world as it is given
+	join,
+	// routine correction on top of a simulation that is already running
+	correction
+};
 
-// restores a snapshot handed to us by the authority. returns false when the blob cannot
-// be used at all - a version we do not know, or damaged content
-bool apply_snapshot(std::string const &Blob);
+struct snapshot_result
+{
+	bool ok{false};
+	// how far the worst vehicle was from where the authority says it is
+	double worst_position_error{0.0};
+	uint32_t vehicles{0};
+	uint32_t repositioned{0};
+};
+
+// packs the state of the world. only ever called on the authority.
+// a full snapshot carries everything and is what a joining peer gets; otherwise only what
+// has changed since the last one goes out, which is what keeps the routine correction
+// stream small
+std::string take_snapshot(bool Full);
+
+// restores state handed to us by the authority
+snapshot_result apply_snapshot(std::string const &Blob, snapshot_mode Mode);
+
+// forgets what was last sent, so that the next delta comes out complete
+void reset_snapshot_history();
 
 } // namespace network