Use type() to create new classes and a factory to instantiate.

Some organizational changes. Previously, if you wanted to add a new trace say, TreeChart, you'd need to add it to graph_references, add a class definition in graph_objs.py, add multiple mappings in graph_objs.py and add it to a couple __all__ lists... which is a lot.

The reason we need to dynamically create classes is because we never know when graph_reference has changed! Therefore, we just do it at import time... Therefore, we were using metaclasses, but this is a little overkill, we can just pass a compiled `__doc__` to `type()` to make a class for us. The doc won't be changing after this, so it's not a problem afterwards.
okay, here's the magic. 

```python
name = 'Something'
bases = (dict,)
d = {'__doc__': "some documentation..."}
type(name, bases, d)
```

... creates a new class, `Something`, which inherits from `dict`, with the docstring, `"some documentation..."`. 

That means, we can just dynamically create all those place-holder classes instead of hard-coding them. Additionally, since this checks to see if they're already defined, it won't overwrite anything that's *been* hardcoded. So this is a pretty tame approach that we can ease into.