Move duplicated successor step creation code to a function

Allow direction to be specified for routing waypoints

Support directionality for zones

Store zone blocks in order and use add_tracks to load them

Don't save an allocated but pending block

It could be a failed turnout which is still set the wrong way.

Cosmetic fixes

Don't attempt to use planned route if no waypoints are set

Initialize the halted flag of dummy driver

Add a dialog to display telemetry data from the driver

Add a common base class for dialogs that need to update dynamically

Use deque rather than list for queues

List makes one allocation for every item, deque only one per a bunch of
items.

Provide some telemetry values from ArduControl

Add telemetry framework for drivers

Improve ArduControl task scheduling

The new scheduler can handle multiple tasks with the same priority, so
other things won't get blocked by the priority command queue for too
long.  It also handles sleeping at the scheduler rather than individual
tasks.

Turn ArduControl command_queue into a Task

It seems that I was thinking of this back in d5d8ee8, but left it
unfinished probably because it was simpler to use a Queue directly.  Now
some upcoming task management improvements call for it to be a Task.

Don't check sequence points while applying routes

The preceding train's routes might not be applied yet.  Instead queue a
sequence check to be done when all routes have been applied.

Correct TrackAttachment entry endpoint

Since endpoint direction points outwards from the endpoint, we want to
find one that's as close to opposite to the TrackAttachment's direction
as possible.

Also check if the clock is stopped

Don't eat away departure delay while halted

Don't segfault if an emergency doesn't have a block

Declare emergency if route planning fails

Abort route planning if it takes too long

Be more permissive when checking route continuity

In some cases more than one consecutive route may end on the same track,
or a route might only go one track past the previous one, with that track
being a turnout with undetermined path.  Allow skipping routes to deal
with these situations, as long as we don't go completely off route.

Ensure that remaining estimate is negative if the waypoint is unreachable

Fix critical block logic

First noncritical block is not reliable, as it could be outside of the
train's allocated blocks and not guaranteed to set to a consistent path.
Worse, the get_first_noncritical_block function could return a block on
the other side of a turnout which is changing path, and is_block_critical
used completely different logic.

Don't allow trains to become blocked in critical blocks

Avoid arriving too early if there's an unexpected stop on the last route

If the final block of the route is allocated while the train is stopped,
arrival could be triggered prematurely.  I'm not entirely certain if this
can happen in absence of certain quirks of the dummy driver, but better
safe than sorry.

Better sequence syncing on route change

Immediately go into the wait state if an uncleared sequence point is
encountered during sync.

Apply all planned routes at once

Letting each router to do it separately in the tick function causes
certain problems with synchronization.  In particular, sequence points
are difficult to synchronize unless the route update is atomic.

Add turnout failure simulation to the dummy driver

Eliminate an unnecessary variable

Unify destination and waypoints

Destination is really just a special case of a waypoint, so there's no
point in keeping it separate.  It just adds duplicated logic, which was
about to get worse with some upcoming new features.

Do not allocate blocks while halt is in effect

A turnout state change signal is emitted even if a failure is detected,
to indicate the end of the operation.  Resuming allocation in such a case
would cause the train to stray to an incorrect path.  It's better to wait
until the user has resolved the situation and removed the halt state.

Use a shared white material for techniques

Instantly set turnout paths when loading state

Vehicles are placed immediately and will follow turnout paths.  Having
them in the wrong places confuses the route planner.

Move block reservation signal serialization to Layout

It needs to be serialized between different blocks as well, since
TrainRouter at least expects to receive the signals in order.

Initialize clock rate field with the current rate

Interpret turnout delay as float, not unsigned

Cosmetic fixes

Use max/min for range capping

Sync timetable to clock on first tick

This is not perfect, but it allows some flexibility in restarting the
program.

Make sure Block::signal_reserved is emitted consistently

Sigc++ apparently takes arguments as references, so if someone reached to
a signal with null train by reserving the block again, any remaining slots
of the release emission would also get the new train pointer.  This caused
the routing system to malfunction in certain cases as the router saw two
emissions for the same block reservation.

The simplest solution would be to pass t instead of train to emit(), but
then the ordering of the two emissions would be inconsistent.  Thus the
additional logic to delay further emissions until the outstanding one is
completed.

Consider block deallocation when planning routes

Blocks are not released until a sensor is detriggered.  Not taking that
into account could cause situations where the planner tries to drive
trains through a balloon loop which is actually too small for them.

Further improve lead route generation

The previous version generated nonsense if the first actual route was
completely covered by existing critical blocks.

Immediately process sequence points that are already covered

The planner starts from the front buffer of the train, so it may generate
sequence points in the existing critical blocks.

Don't diverge from critical blocks

Doing so could confuse the router.

Improve metrics_stale flag handling

Eliminate a possible race condition in thread termination

In the unlikely event that the thread doesn't terminate fast enough after
setting the goal pointer, deleting it would send it a kill signal.
Remove this possibility by explicitly jouning the thread.

Allow an undetermined turnout at the beginning of a route

If route plans are regenerated when the train's last vehicle is on the
sensor following a turnout in a points-facing movement, the first track
of the lead route is a turnout with undetermined path.  Route_changed
would then try to figure out which route the next allocation will occur
on and fail at the very beginning because advance_to_track refused to
use the undetermined turnout.

Restructure lead route generation

All of the relevant logic is now in one place.

Don't access waypoint and metric data if the router has no destination

Don't use bool for a counter variable

Penalize steps other than the fastest one

This encourages the planner to follow a single chain of steps and avoids
exploding the state tree too much.  In the future this may be replaced by
different speed limits on diverging paths of turnouts (reducing the
ambiguity of fastest path) and an actual heuristic for potential wait time
(giving wait states an implicit penalty).

Store routing information in TrainRoutePlanner to avoid threading problems

TrainRouter removes checkpoints when the train passes them, which will
cause problems if the planner is still running.

Resume allocation if a train moves out of its own way

The normal handling in block_reserved() does not work, since by that time
release_block() has already cleared pending_block.

Unoccupy destination during planning when the train has departed again

Eliminate the one step delay in adding tracks to routes

It is no longer necessary now that we inspect linked tracks to detect
loops.  Removing it makes the logic easier to understand.

Make route planning threaded

It can take several seconds in some cases, which would cause an
unacceptable pause in simulation and control.

Avoid creating needlessly long lead routes

Mostly a cosmetic fix.

Skip routes that are completely covered by the lead route

Advance_to_track throws a fit if no advancement happens from one route to
the next.

Update routes for all involved trains when planning completes

Sequencing is likely to have changed even if routes haven't.

Avoid going past the end of route when a new one is set

Calling stop_at(0) causes the block allocator to immediately resume
allocating blocks.  In certain circumstances this would cause an
allocation past the end of the route.

Make sure the shadow volume does not have zero size

Improve accessory switching logic

The off command can be sent as soon as the current monitor indicates that
the solenoid is no longer drawing power.  This allows giving multi-bit
accessories more time to accommodate quirks of the 74465 decoder.

Add debug output for accessory switching in ArduControl

Avoid invalid states when setting multi-bit accessories

Add a dialog to control the clock

Ensure that Timetable has necessary helper AIs

Since AIControl and TrainRouter don't emit statements to the state file,
they are not created automatically when loading the state.  If they are
missing, the timetable won't be able to operate.

Adapt to changes in vector slicing and composing API

Set lighting for the sky pass too

Otherwise whatever parameters were there before will get used, resulting
in incorrect rendering with multiple views.

Improve lighting color computations

This produces a bit too bluish skylight and a bit too reddish sunlight,
but it's a step in the right direction.

Improve graphics quality with some shaders and effects

Lighting is now carried out in linear colorspace and sRGB conversion
applied in postprocessing.  All these effects will probably make the
program really slow on lower-end machines, but I'll fix that later.

Get rid of some obsolete #includes

Avoid segfault if an exception is thrown while loading

The Layout::add functions are called from object constructors.  If an
exception is thrown inside them, the constructor will abort and the
object will be deleted.  If that happens, it must be removed from the
Layout as well, or an invalid memory access will occur later.

Reorganize data files into a directory structure

All object types have been split out of the *.dat files into individual
files.  As a side effect, their names have acquired a type-specific
suffix.

Be more consistent with the use of name and description

Remove some unnecessary things

Rework article numbers

Avoid crash in SlopeTool if nothing is selected

Support multiple TrackAppearances in Catalogue

Convert Catalogue to a Collection

Since this involves changing the key from ArticleNumber to std::string,
existing layout and state files need to be adjusted by hand.

Things with different gauges don't go together

Add a shortcut for getting the gauge of a TrackType

Also store gauge in VehicleType

Set depth clip in View3D::view_all

Fix a bug with attaching ends in ExtendTool

This managed to avoid a segfault despite the null pointer dereference,
because the first thing Track::link_to does is check if the passed-in
reference is a track, and a null pointer isn't.

Move gauge to TrackAppearance

It may eventually be desirable to have multiple gauges in the same layout
(narrow-gauge trams together with a standard-gauge railway, for example),
and this is a necessary step towards that.

Overhaul SvgExporter to use SVG defs for tracks

This produces much more compact SVG files than outputting the paths for
each track separately.

Use GL::Resources and DirectorySource in Catalogue3D

Improve comments

Always handle sequence checks in tick()

Begin arrival immediately if the entire route has already been reserved

Keep routes until the train has completely left them

Tinker with arrival logic

Add a signal for advancing the rear end of the train

Move members after type declarations

Remove a function that was never used

Keep better track of routes

Finding the correct route for each allocated block from scratch is prone
to errors if the combined route contains loops.

Simplify sequence handling

Instead of checking all sequence points when another train reserves a
block, only check the first one.  The subsequent ones can be checked
when they become relevant.

Redesign the interface between TrainRouter and TrainRoutePlanner

This will make it easier to move planning to a separate thread in the
future.