Allow to load and store between virtual datum and any tuple like type

[bernhardmgruber]

A virtual datum can be seen as a tuple/struct of references. This PR improves interoperability between a virtual datum vd and user defined structs:

vd.loadAs<T>() and T value = vd.load(); allow to load the referenced data represented by a virtual datum into a type T, if T adheres to the following requirement:

• T is direct list-initializable from a sequence of U... or U&..., where the pack U denotes the types referenced by the virtual datum. In other words, the expression T{std::declval<U>()...} must be valid.

vd.store(const TupleLike& t); allows to store a value of a tuple-like type into the referenced memory locations of the virtual datum. Requires:

• TupleLike to by a type for which std::tuple_size_v<TupleLike> and get<I>(std::declval<TupleLike>()) (for I in [0;std::tuple_size_v<TupleLike>[) are valid expressions.
• The tuple sizes of TupleLike and recursively its data members are the same as the tuple sizes of the virtual datum and its sub-virtual datums.

Examples are found in the unit tests. Motivating example:

using DD = llama::DS<
    llama::DE<tag::Pos, llama::DS<
        llama::DE<tag::A, int>,
        llama::DE<tag::Y, int>>>,
    llama::DE<tag::Vel, llama::DS<
        llama::DE<tag::X, int>,
        llama::DE<tag::Y, int>,
        llama::DE<tag::Z, int>>>,
    llama::DE<tag::Weight, int>>;
...
struct MyDatum {
    struct MyPos { int a, y; } pos;
    struct MyVel { int x, y, z; } vel;
    int weight;
};
... // tuple protocol for MyDatum

void f() {
    llama::One<DD> vd;
    MyDatum d = vd.load(); // loads from virtual datum into a user defined struct
    d.vel.y += d.pos.y;
    vd.store(d); // stores from a user defined struct into a virtual datum
}