Discrete model connector input types

[Caellian]

Simulation shouldn't care about event types models receive past the validation step.

• Validation should report any routes connecting invalid TypeIds.

Models should be able to take in (virtually) any number of inputs and provide any number of output lanes.

• Due to language limitations (namely variadic generics) the actual number of supported inputs and outputs is capped at 12 like some tuple impls in std lib, that seems like a reasonable limit for now.

Models are 'static, as are input and output declarations. This restriction is necessary as changing input and output counts/types while a simulation is running makes it incredibly cumbersome to detect changes and handle model validation which would slow down the simulation for most normal use cases.

Erasing model inputs and outputs sacrifices performance when compared to previous design due to additional vtable lookups (untested), but vastly improves: DX, (incremental) compilation time and simplicity of the implementation.

• Namely, specializing Model trait for 12×12 IO would require insane amounts of generated code to support.
  • If such a simulation performance is required it's better to write a simulation from scratch anyway with entirely discrete types.

Modelling inputs as a struct bears the limitation of requiring all inputs to be provided at once or user facing code having to shift through multiple Option wrapped values which isn't the nicest interface. And given that a macro can generate several traits to support a much nicer interface at the cost of very little compile time, using HeterogeneousTuple seems like a much nicer approach.

• HeterogeneousTuple works much like variadic generics would anyway so it provides a nicer transition trajectory for adaptation of existing code base once Rust gets them.
• HeterogeneousTuple approach depends on specialization, auto_traits, and negative_impls unstable features to work.

And finally, user facing code should be straightforward to implement which means:

• No duplicate type declarations.
  • Most types should be inferred by the compiler by returned data types.
• End-user doesn't need to specify any lifetimes.
• Model implementation should be dead simple for simple models.

[Caellian]

The described behavior has been achieved by erasing connector types before they're attached to models, which avoids the need for HeterogeneousTuple type which was hard to reason with on type system level.

While the current implementation is more verbose, it's A LOT easier to implement as it doesn't require compiler extensions and nowhere near as many unstable Rust features.

Impl of Models is simplified by using a proc_macro.