Fix STL crash in ROOT < 5.34.03

#149 should be merged first.

The build fails with 5.32.04 due to adding the call "create_buffer()" in test_stl. The tests stall after the infamous lines (from cint/cint/src/loadfile.cxx):

```
301.INFO:rootpy.stl] generating dictionary for vector<vector<int> > ...
302INFO:ROOT.TUnixSystem.ACLiC] creating shared library /tmp/tmpZi1J99/i686-53204/modules/2340b41f304863fb.so
303Note: (file "(tmpfile)", line 2) File "vector" already loaded
304Note: (file "(tmpfile)", line 2) File "vector" already loaded
305Note: (file "(tmpfile)", line 2) File "vector" already loaded
306Note: (file "(tmpfile)", line 2) File "vector" already loaded
307Note: (file "(tmpfile)", line 2) File "vector" already loaded
```

Like we saw before, this is a stack overflow:

https://gist.github.com/4283235

ROOT is bouncing back and forth between TClass::GetClass and TROOT::LoadClass until the stack overflows:

```
#41828 0x00007ffff4481671 in TROOT::LoadClass(char const*, bool) const () from /home/endw/software/root/current/lib/libCore.so
#41829 0x00007ffff44e7acf in TClass::GetClass(char const*, bool, bool) () from /home/endw/software/root/current/lib/libCore.so
#41830 0x00007ffff4481671 in TROOT::LoadClass(char const*, bool) const () from /home/endw/software/root/current/lib/libCore.so
#41831 0x00007ffff44e7acf in TClass::GetClass(char const*, bool, bool) () from /home/endw/software/root/current/lib/libCore.so
#41832 0x00007ffff4481671 in TROOT::LoadClass(char const*, bool) const () from /home/endw/software/root/current/lib/libCore.so
#41833 0x00007ffff44e7acf in TClass::GetClass(char const*, bool, bool) () from /home/endw/software/root/current/lib/libCore.so
#41834 0x00007ffff4481671 in TROOT::LoadClass(char const*, bool) const () from /home/endw/software/root/current/lib/libCore.so
#41835 0x00007ffff44e7acf in TClass::GetClass(char const*, bool, bool) () from /home/endw/software/root/current/lib/libCore.so
```

Minimal script needed to reproduce:

```python
from rootpy.io import open
open('test_dicts.root').data.create_buffer()
```

where `test_dicts.root` is `rootpy/testdata/test_dicts.root`

Just to repeat what we already know: this is not a problem in ROOT 5.34.03

The segfault does not occur if I request the dictionaries before opening the file:

```Python
from rootpy.io import open
from rootpy import stl

stl.vector('vector<int>')
stl.vector('vector<float>')
stl.vector('vector<string>')
stl.vector('vector<vector<float> >')
stl.vector('vector<unsigned int>')

open('test_dicts.root').data.create_buffer()
```

Interesting.... so this crashes (opening file containing a tree with stl type banches):

```Python
from rootpy.io import open
from rootpy import stl

with open('test_dicts.root') as f:
    stl.vector('vector<vector<float> >')
```

but this does not (creating a new file):

```Python
from rootpy.io import open
from rootpy import stl

with open('test_123.root', 'recreate') as f:
    stl.vector('vector<vector<float> >')
```

and this does not (opening existing file without a tree with stl types):

```Python
from rootpy.io import open
from rootpy import stl

with open('test_file.root') as f:
    stl.vector('vector<vector<float> >')
```

Just by opening a TFile containing a TTree with STL types puts TClass entries in the global list of classes as can be seen by printing gROOT.GetListOfClasses() before and after opening and closing the test_dicts.root file.

`class.IsLoaded() == False` for these STL types though.

Ah! Found a way around this!

```Python
from rootpy.io import open                                                      
from rootpy import stl                                                          
from ROOT import gROOT                                                          
                                                                                
with open('test_dicts.root') as f:                                              
    pass                                                                        

# the next two lines are critical                                                        
cls = gROOT.GetClass('vector<vector<int> >')                                    
gROOT.GetListOfClasses().Remove(cls)                                            
stl.vector('vector<int>')
```

The above runs without segfaulting. Seems that if I remove all STL TClasses from the global list before using stl to load/generate them, then all is fine.