Consider different inheritance patterns

[arcondello]

There are two approaches if we want to go this direction:

Virtual inheritance

See #74 for an example.

The advantage is that we can mix several different inheritances. E.g.

struct Node {};
struct Decision {};
struct Array {};

struct ArrayNode : public Array, public virtual Node {};
struct DecisionNode: public Decision, public virtual Node {};

struct ListNode : public ArrayNode, public DecisionNode {};   //<- this is allowed with virtual inheritance.

The downside is a minor performance hit. Because now ListNode does not necessarily know where in memory the "node parts" are.

Direct inheritance

In this case we just do

struct ArrayNode : public Array, public Node {};

The upside is performance. All the array/node points know their relative position. The downside is that we cannot as easily add/compose new node types. So we end up doing things like

struct Node {};
struct Decision {};
struct Array {};

struct ArrayNode : public Array, public Node {};

struct ListNode : public ArrayNode, public Decision {};

Next steps

Performance testing needed.

[arcondello]

One way we could potentially mitigate the performance hit of virtual inheritance is with liberal use of the final keyword for classes. Though that would make maintaining binary compatibility in the future a bit more tricky.