Avoid sending a packet to the same connection more than once

To keep things efficient, player IDs are now stored as 32-bit quantities,
with the high 16 bits containing an ID for the client connection.  Only
the lower 16 bits are transmitted on the network to avoid leaking
information on which players share the same connection.

Streamline the send functions in Replicator a bit

Calling the targeted send function with a target of zero will now forward
to the broadcast function, avoiding the need to branch at call sites.

Track the sender of the current packet

Add facilities to designate entities as player-controlled

Fix errors revealed by gcc 13

Rework Landscape to support replication

Add a dynamic cast function for Owned

Add a callback when an entity is spawned over the network

It can be used by the owner of the spawner to send additional packets
to initialize the entity.

Add a mechanism for replicating function calls to clients

Support custom lookup functions for retrieving setups in Spawner

Give IDs to entities replicated over the network

Only send spawns to the target players of the replicator

Send spawns of newly-created entities in deferred_tick

Spawn info won't have been set in the component_create event for the
zygote.

Add a mechanism for spawning entities over the network

Add interfaces for using Networking from the outside

Emit events when the other side of a network connection changes stages

Rename Networking::next_id to next_player_id

Use Networking::set_state in start_server and connect_to_server

This gets the event appropriately emitted.

Add string interning to the network protocol

This allows transmitting commonly used strings using short IDs.

Identify stages with a name

Remove unnecessary std::ref invocations

I got confused by the std::thread constructor, which stores its arguments
in a tuple and creates copies without std::ref.  It's not needed in these
cases since the arguments are just forwarded directly.

Place Networking after event things in Director

It uses the event bus, so correct order of destruction must be ensured.

Rename some events for clarity and consistency

Support adding prop entities to Landscape

Add support for shadows

Track destruction of individual components in Renderer

Allow clearing an Owned by assigning nullptr

Make Owned friendly to other template specializations

Make iterate_objects const

Chain certain pool operations to pools of derived objects

Keep track of object pools for derived types

Make the destructor of PoolBase virtual

Make pools non-movable

I'm not actually using move semantics for them and they're of dubious
value due to polymorphism anyway.

Add a generation number to Reflector

Include generated headers from the installed location

Add game setup imports as transitive dependencies

Update location of generated source files

Add components and systems for creating terrains

Make Presenter store pointers to systems, not just renderers

Add a component for using dynamic meshes in entities

Adjust Bassteroids for the lighting changes

Create the rendering sequence dynamically

Sequence templates are a bit too rigid for games where it's desirable to
tune many different graphics quality settings independently.

Add components for creating lights

Further refactor Renderer and MeshRenderer

The ObjectInstance is now hidden inside MeshRenderer and RAII is used to
remove it from the scene.  This limits the instance to being in only a
single scene, but I don't think that will be an issue.

Add a transform propagator to stages by default

This is possible now that system dependencies have been implemented.

Refactor Renderer to pick up components instead of entities

This makes more sense since there isn't an entity class which always
contains a MeshSource.

Have MeshRenderer's constructor take a GL::Object

Undefine the API macro at the end of a setup header

Otherwise it may interfere with other setup headers.

Add basic networking infrastructure

Currently it only allows running a server, connecting to it and creating
players, but no synchronization yet.

Derive GameSetupDefinitions from TemplateFile instead of SourceFile

Builder's InstallMap checks for that class to figure out the install
locations for generated headers.

Update .gitignore files

This includes pre-emptive changes for Windows build products.

Load the various setups through resources

Add dependency to mspmath in Bassteroids

Use the setup generator to create setup structs

Support API decorations for setups

Prefix C++ types with namespaces in the setup generator

Add import functionality for setup modules

Also install setup definition files so definitions from libraries can be
used.

Refactor the setup generator to store types in modules

Create a builder plugin for the setup generator tool

Remove a temporary hack

The bug it was for is now fixed.

Add an include which is now necessary

Changes in the Variant class require classes retrieved from a collection
to be fully defined.

Decorate things which constitute the public API of the library

Add a tool for generating setup structs and loaders for them

Adjust system dependencies to resolve scheduling ambiguities

Schedule systems based on their declared dependencies

Add flags for declaring ordering between systems

Make it possible to find reflected classes by RTTI

Add move constructor and assignment from Owned of derived type

Change Owned's constructor to take a pointer to the parent

This avoids some awkwardness with overload resolution

Cosmetic fixes

Minor optimization to AccessGuard::check

It doesn't need to resize the vector since it can just use the default
flag.

Report which system caused invalid access

Enforce correct access to buffered components

Convert components to buffered where appropriate

Implement base support for buffered components

They hold two copies of data, one being read from and the other written
to.  This makes it easier to write concurrent and order-independent code.
Systems can declare dependencies to such components to have their prepare
and commit functions called automatically.

Plug a memory leak in EventBus

Add unit tests for the event bus

Add unit tests for reflection

Add reflection infrastructure

This allows checking for type relationships at runtime, which will be
useful for annotating system dependencies and iterating over subclasses.

Defer creation of bullets until the end of the frame

Enforce no creation or destruction of objects during tick

Make asteroids take damage when shot and eventually be destroyed

Remove destroyed entities from the physics simulation

Emit events for colliding physical entities

Pass bullet's initial transform values directly to the constructor

Disable keyboard autorepeat by default

It's usually undesirable in games, and the setting doesn't affect
character input.

Make it possible to shoot bullets in Bassteroids

They don't actually do anything yet except bounce around.

Initialize Transform's matrices to identity

Fix various cases of bad math

Add missing initializer for player ship's moment of inertia

Use the correct inertial quantity for calculating velocity change

Don't apply more friction than it takes to nullify the velocity

Simulate friction in collisions

Add a controllable player ship to Bassteroids

Allow external forces and torques to be added on rigid bodies

Add rotation to physics simulation

There's no friction yet, so colliding objects don't start rotating.

Add infrastructure for receiving player input

Add playfield boundaries to Bassteroids

Implement box colliders in Bassteroids' physics system

Provide a way to request events for existing entities and components

The iterate_objects function does not account for derived classes, so
iterating over all Entity instances might not actually give all entities
on the stage.