Fix some bugs in tools

Improve algorithms in several editing tools

Improve block recreation algorithms

These changes result in a more than 100% performance improvement in
operations that create and delete a lot of tracks, such as the extend
tool.

Split the Manipulator class into several Tools

It was getting a bit huge and unwieldy, especially with things like
terrain editing on the horizon.  Not all tools need the same information
or in the same format.

Add a utility function to get path length from Track

This shortens the incantation to get the length of the active path.

Complete BR 50's rod setup

Support mirroring only a subset of rods based on a tag filter

Remove an unused enum from Vehicle

Immediately update rods when a vehicle is created

The initial positions are not guaranteed to, and usually do not satisfy
the constraints.

Rewrite rod simulation code

Instead of trying to get a perfect solution on the first try, solve rod
interconnection constraints iteratively.  This simplifies the code and
allows for certain rod configurations that would have been prohibitively
difficult to solve exactly.

It's now also possible to create a mirrored set of rods on the other side
of the locomotive with a single statement.

Remove the now-unused async picking code from Engineer

Minor fixes

Move goto destination picking to RouterPanel

Add a utility class to display a TrackChain as a path

Use Widget::find_ancestor to reduce code duplication

Correct camera distance in side view

Avoid infinite loops in VehiclePlacement in certain situations

Fix a crash when reversing certain TrackOffsetIters

Reserve enough blocks for the entire train when placing

Better visualization for placing a train

Still far from perfect, but it's a start.

Fix allocation display when a train is chasing another

Split vehicle placement code to a separate class

I'm going to need this elsewhere soon.

Store all axles in a single array

Create a common base class for Vehicle3D parts

Properly detect blocks as critical when a train is not moving

Ignore path change events on currently occupied blocks

Avoid a temporary inconsistent state while reserving the first block

Use the tilt member in OrientedPoint in certain objects

Rename TrackPoint to a more generic OrientedPoint

The grade member was also changed to a tilt angle, which is a better match
to how Object orientation is specified.

Create another track iterator class that holds an offset as well

Make use of View3D in engineer

New approach for displaying track state

Paths can now be displayed over either rail in addition to the center of
the track.  Track circuit and allocation state are displayed separately,
allowing more information to be shown.

Instead of pre-creating a path for each track, only create them as needed.
Local controller objects are much more manageable than bundling everything
into one giant class.

Add an out-of-bounds check to SpeedQuantizer::get_speed

Just in case the previous fix wasn't the only place that could generate
bogus values.

Fix uninitialized variables in Intellibox driver

Uninitialized pending_half_step caused wonky loco speed events to be
emitted, resulting in out-of-bounds access in speed quantizer.

Use beam gates for positioning vehicles

Refactor and fix vehicle positioning logic

Fix block releasing logic

The previous attempt didn't release any blocks if the last vehicle was
still behind the last active sensor, which is almost always the case.  And
if it did manage to release anything, it would have released too much.

Move driver.add_sensor call where it belongs

Basic support for beam gate sensors

Support inverted sensors that give low output when active

Add a non-const overload of Layout3D::get_catalogue

This is necessary for automatic loading of resources.

Add a function to retrieve track attachments in order

Some more refactoring of BlockAllocator

Immediately update the matrix after creating an Object3D

This fixes a problem with the catalogue layout's contents being displayed
incorrectly.

Don't reset router to free run mode until allocator has deactivated

Setting route causes stop_at information to be cleared.  If the allocator
is still active when this happens, it will allocate more blocks.

Refactor BlockAllocator to be more sensor-oriented

This is necessary for soon-to-be implemented beam gate sensors.

Keep TrackAttachment offset within allowed limits

Add a virtual get_block function to Sensor

Only create track circuits for blocks that need one

Remove a hack that is no longer necessary

Remove deprecated datafile statement aliases

Use generic objects in Layout3D

Prevent segfault during layout destruction

Add an abstraction for things that are attached to tracks

Use event-based matrix updates for objects

Introduce a tilt (vertical angle) property to Object

Complete rewrite of the engineer UI

The fixed column of train controls was getting unwieldy with lots of
trains, and side dialogs didn't move with their associated train panel.
Now, all dialogs are movable and train controls only appear when
requested.  Most of the former side dialogs have been integrated into the
train dialog as tabs.

Further adjustments to changes in GLtk

Layout subclasses were transformed to Arrangements, and Lists and
Dropdowns work a bit differently.

Don't continue reserving until the turnout is done changing its path

Count reserved distance correctly in reverse direction

Delete auxiliary objects together with Vehicle3D

Add signals for adding and removing vehicles

Activate allocator if an AI intends to move

Make train advancement logic more robust

Set pending_block when a block can't be allocated

This got accientally removed in dda1e6c

Give vehicle types a simple box geometry

Make vehicles aware of which train they are in

Redesign the train activation system

It was getting rather messy and there was one or two bugs where block
allocation didn't resume correctly.  The flag now resides in
BlockAllocator.  Rather than poking at it directly, AIs can express an
intention of moving the train.  This should help keep things in sync
with each other.

Emit a signal before changing the path of a turnout

Since changing the path is an asynchronous operation, this lets other
components react to an impending change.

Angle must be divided by the correct type

Fix BlockAllocator so that it actually compiles

Fix some issues with BlockAllocator::release_blocks_end

Use std::find to locate block iterators in BlockAllocator

Arrange widgets in Designer with GLtk::Layout

Make the simulation independent of wall clock time

Layout now holds a Clock object, which keeps track of simulated absolute
time and can advance faster (or slower) than the system clock.

Remove the scripting-based timetable

I'm going to implement a proper timetable soon, but some other changes
need to happen first.

Better algorithms for dealing with turnouts in a Route

Make use of the unified storage class for other parts of Layout

Streamline various block-related algorithms

Ensure that turnout tracks have a turnout id

Create a base class to handle common operations in Block, Route and Zone

Reduce interface clutter in Layout by storing Objects in a uniform way

Handle sensors in a separate class

Tighten safety measures

Remove opportunistic freeing of blocks from behind the train and counting
of noncritical blocks from the simulated vehicle position.  Both features
are now implemented in terms of what can be ascertained from sensors.  I'm
developing infrared gates which will provide similar functionality with
actual physical (or simulated) feedback.

Fix a problem with TrackIter::block_iter at end of line

If the track iterator was already on the last track, the check for
returning an empty block iterator would not get executed, and the throw
at the end of the function would get triggered.

Improve the interface and algorithms of BlockAllocator

Simplify some interfaces by using track and block iterators

Split block allocation to a separate class

Pull the SetFlag class from mspcore

Don't fail when adding multiple tracks to an initially empty Route

Report all missing flags in bad_route

This was the intention from the beginning, but somehow else statements
slipped in.

New routing system for trains

The earlier code routed each train separately and tried to deal with
conflicts as they arose.  The new system instead considers the entire
layout and simultaneously finds routes for all trains.  It is able to
have trains wait for each other, and in the future many new tricks can
be added.

Plug several memory leaks

Add the signal to the catalogue layout

Register pre-existing signals in Layout3D constructor

Don't force signals to be positioned next to track

They can now be positioned freely and will logically attach to a nearby
track.

Snap to segments in both directions

Choose whichever is closer to the current rotation.

Refactor TrackIter::block_iter

The new implementation is slightly more efficient in certain cases and
won't choke at the end of a line.

Make use of the geometry part of libmspmath

Don't zero slope for tracks not connected on both ends

Since check_slope is now called implicitly when linking tracks together,
loading layouts with sloped tracks wasn't working properly.