multiplayer stage 7: versioned snapshots instead of replaying the session

Joining meant replaying backbuffer.bin from the very first frame of the
session, so the longer a session ran, the longer it took to get in - and the
whole history had to be kept for it.

- network/snapshot: a chunked container with a version of its own. Every
  section carries its length, so a peer built before a section existed reads
  a newer snapshot and simply walks past what it does not know. Version 1
  carries the session (tick, clock, weather, the state of the random engine),
  the vehicles (position on the track, speed, direction, controls, brake
  pressures, whether the AI is driving) and the crew roster. Switches,
  memcells, signals and the event queue are the next sections
- joining is now: handshake -> load the scenario -> CLIENT_READY -> the server
  takes a snapshot on the spot and sends it -> the peer goes live. Because the
  snapshot is taken at the moment the peer becomes active there is no backlog
  to replay at all; the frame by frame catch-up is gone
- the server refuses a peer that loaded a different scenario, with a readable
  reason instead of a silent desync
- reconnecting into a session that is already loaded asks for a fresh snapshot
  straight away rather than waiting for a loader that will not run again
- a vehicle is only put back on the rails when it really is somewhere else; the
  arithmetic that turns the recorded bogie offset back into the nose distance
  place_on_track() expects mirrors what that function itself does
- the session log is still written out - it is useful when picking a desync
  apart - but nothing depends on replaying it any more

network/message.h

@@ -21,6 +21,8 @@ struct message
 		CLAIM_DENIED,
 		LEAVE_VEHICLE,
 		CREW_UPDATE,
+		CLIENT_READY,
+		SNAPSHOT,
 		TYPE_MAX
 	};
 
@@ -85,6 +87,30 @@ struct vehicle_list : public message
 	virtual void deserialize(std::istream &stream) override;
 };
 
+// sent once the joining peer has the scenario loaded and can take a snapshot
+struct client_ready : public message
+{
+	client_ready() : message(CLIENT_READY) {}
+
+	std::string scenario;
+
+	virtual void serialize(std::ostream &stream) const override;
+	virtual void deserialize(std::istream &stream) override;
+};
+
+// the state of the world as of one particular tick, handed to a peer that is joining.
+// this is what replaces replaying the whole session from its first frame
+struct snapshot : public message
+{
+	snapshot() : message(SNAPSHOT) {}
+
+	uint64_t tick{ 0 };
+	std::string blob;
+
+	virtual void serialize(std::ostream &stream) const override;
+	virtual void deserialize(std::istream &stream) override;
+};
+
 // a peer asking the server to be put on the crew of a vehicle
 struct claim_vehicle : public message
 {