Remove concept of the groups module, simplifying generated code.

[rooooooooob]

Now all field are represented directly inside of the main code,
so instead of both lib.rs having

struct Foo(groups::Foo);

and groups.rs having

struct Foo {
    x: u32,
    y: u32,
}

we now have only lib.rs having the group structure, but also having the
wasm exposure and other exposed functionality that the lib.rs had
before.

This simplifies in-library client code (wasm interface is unchanged)
as instead of self.0.x.0.y.0 we can just write self.x.y and be much
more readable.

This existed before as plain groups and their usage used to be
code-generated in separate steps, as well as a desire to be generic for
both array vs map representations. This does not matter anymore though
as the two (group vs concrete representation) had already became coupled
(and rightfully so) along the way.

TaggedData<T> was also removed to make access within the code-generated library simpler as well. Instead of having to do x.data everywhere we can directly access
the tagged data as x.

This means we no longer store anything pertaining to tags anywhere
except the serializaiton code, making any use from within the generated
rust library much less ugly and more obvious, as well as reducing
overall code size. We also no longer need to generate those redundant
UntaggedFoo structs.

Before:

struct UntaggedFoo {
    x: uint,
    y: uiny,
}

pub struct Foo {
    data: TaggedData<UntaggedFoo>
}

impl Foo {
    pub fn new(data: UntaggedFoo) -> Self {
        Self { data: data }
    }
}

After:

pub struct Foo {
    x: uint,
    y: uint,
}