Serialization
-------------

Solutions:
1. Manual (de-)serialization with compiler checks, so no field gets forgotten.
2. Typeinfo that is passed to a serialization library that does some kind of
   reflection-like operations using the typeinfo (Note: This has to take
   lifetimes, aliasing and modifiability of fields and nested structures into
   account)
3. Compiler-generated calls to the (de-)serialization library of choice.


    func .deserialize_from_der(arena, byte[] bytes) -> Thing or DeserializationError {
        Thing ret = .allocate(arena)
        # XXX temporary arena for parsing?
        DerSequence seq = .from_bytes(arena, bytes) or .malformed
        #Iterator<DerItem> iter = seq.iter()
        DerIterator iter = seq.der_iter()
        ret.a = map_to_some_enum(iter.oid())
        ret.b = iter.integer()
        ret.c = iter.octet_string()
        return ret
    }

Tricky parts:
- enums may be encoded in many different ways in different formats (number, string, OID)
- some formats have multiple different integer types (e.g. uint16, int32, ...)
- some formats have multiple different string types (e.g. PrintableString, OctetString, UTF8String, ...)
- some formats have a choice/variant type, and others don't
- some formats have optional fields, and others don't
- formats can have different case rules. Some might use UpperCase fields, which won't work with SLUL.