Implement derive macro for ToVariant and FromVariant

[ghost]

The derive macro does the following mapping between Rust structures and Godot types:

• Newtype(inner) is unwrapped to inner
• Tuple(a, b, c) is represented as a VariantArray ([a, b, c])
• Struct { a, b, c } is represented as a Dictionary ({ "a": a, "b": b, "c": c })
• Unit is represented as an empty Dictionary ({})
• Enum::Variant(a, b, c) is represented as an externally tagged Dictionary ({ "Variant": [a, b, c] })

---

For ease of use, ToVariant and FromVariant are also implemented for Option<T>, Result<T, E> and Vec<T>. Vec<T> silently drops values for which from_variant failed, but the composition with Option<T> works nicely, in case it's necessary to know which items failed.

Support for more collections should probably come in the form of iterator support for Godot types, as there is no real way to return or take a BTreeMap from Godot, and maps in general can probably have surprising behaviors when their keys are non-primitive (value equality in Rust vs possibly reference equality in other languages).

Fixes #186.

[karroffel]

This is really cool, I like it! Apart from the code for the generic bounds this is also relatively simple to follow, it's nice :)

[ghost]

The code for the generic bounds are initially adapted from serde_derive and is still going through changes. I'll refactor it to make it easier to read!

[karroffel]

Yes I saw the comment that it was taken from serde, so no worries. I think this approach is fine and once this is out of draft phase I would have no problem merging this.

[ghost]

Added derive macro for FromVariant, and implemented the conversion traits on some common types. I think it's ready now.

Rebased on master because of merge conflicts.

[ghost]

If we want Option<T> to be stricter we can write this instead for FromVariant:

fn from_variant(variant: &Variant) -> Option<Self> {
    if variant.is_nil() {
        Some(None)
    }
    else {
        T::from_variant(variant).map(Some)
    }
}

...so it returns None for non-Nil values that can't be converted to T.

But then we can no longer write Vec<Option<T>> for an array that may contain things that are not T. Maybe a new wrapper type needed here?

---

Added one.