Added rudimentary style handling...

Style objects can be used just like Format objects, but are referenced back to
a common styles dictionary, which can contain Formats, sums of Formats (which
at the moment end up being StringWithFormatting objects) or even other Style
objects.

The amount of passing around of the styles dict that I'm doing at the moment
makes it feel like something is still a bit wonky in my architecture - possible
the draw_block(s) stuff should move off of Terminal and into Root.
Started move towards making terminal even less aware...

of Format/Style objects and really just deal with strings and drawing them to
the right places.
Improve repr of Block objects
Refactor element drawing/formatting code...

This is quite a big one, partly because unpicking things started to have
knock-on effects! Headlines:
 - Made Terminal less 'smart' (i.e. more like the original blessings') so that
   drawing a block really is now just printing out a bunch of lines in the
   right places. It no longer knows about changing defaults for what 'normal'
   is.
 - Made elements pass back up their data to draw again, so that they don't need
   handles to terminal, styles and what have you - that's all now handled by
   whichever element ends up being at the top of the tree and having draw() or
   update() called on it. The abstracted out methods for just getting all the
   data to draw are currently called get_all_blocks() and get_updated_blocks()
   respectively.
 - Tried to consolidate all of the escape sequence resolving or 'populating'
   code in one place, on StringWithFormatting. It's getting there.
 - Made the Root 'element' actually an element, which merely handles draw() and
   update() calls a little more cleanly than a regular element, and provides a
   neat place for users to build Format and Style objects from.
Rename LazyLookup to Placeholder...

It's more descriptive of what it's for and less of how it works.
Fix default formats...

I made one change too many in the unit tests!
Massive, massive, massive refactoring of how formatting code works!...

WARNING: the tests don't quite pass, there are some old formatting unit tests
which I haven't disposed of yet, and the API isn't quite how I'd like it yet.

Headlines:
 - Added more classes in formatting.py to deal with some concepts of
   StringWithFormatting objects more explicitly (they may end up going away
   again, but help in the interim with working out the details of all the
   problems)
 - Placeholders are now more lightweight
 - There's an interim 'StringComponentSpec' class, which forms the base unit of
   StringWithFormatting
 - StringWithFormatting is now a slightly more lightweight container, that has
   different containment logic, which has hopefully made it simpler
 - This meant word wrapping needed to be tweaked, as we no longer get presented
   with a single stream of 'character' data from a StringWithFormatting
 - The API currently only supports doing things like Root.format.blue('word'),
   not Root.format.blue + 'word', because it made things simpler. I plan to add
   some flexibility back right away.
Fix some problems in drawing chain...

 - Temporarily removed concept of drawing 'normal' and default escape sequences
   because it's going to be improved somewhat soon
 - Fix tests and example to use more limited formatting API (i.e. only calls)
 - Made a NullPlaceholder that renders no format stuff, as it seemed more
   symmetrical than having the NullSpec thing have a random populate method...
 - Add and end-to-end test to work out draw-chain bug
Implement a stack for escape sequences...

so that we can 'undo' the application of escape sequences heirarchically.
Fix default_formatting example exception...

When used as a default_format, the bool cast caused by simply doing a 'default
or default' was causing an exception because of the implicit use of __len__
Make basic default_formats work again...

Now can use a single Root.format.<name> as a default_format on an element
Add 'updated' property to Root...

because otherwise things like the LineInput have stopped working.
Remove ABC stuff from formatting...

No one outside of us is going to subclass these, so this just makes things
simpler.
Make interface for placeholder population uniform
Remove method dispatcher for style/format population...

as everything should now have the same interface.
Refactor calling to produce string component specifications...

 - This stems from the idea that the thing you get back from a
   Root.format.<name> should actually be a Placeholder, like we had before
 - This means we should be able to cope with using Placholders to specifiy
   Styles with just normal access in the same way that we use for making
   strings with actual content :-)
 - The main thrust of this refactor is to move __call__ from the
   StringComponentSpec to Placholder
 - This required changing the parameterizing specialisation from Spec to
   Placeholder (hence the removal of the ParameterizingStringSpec class and the
   creation of the new ParameterizingFormatPlaceholder class)
 - Unit tests needed to be updated as appropriate, with some that no longer
   apply being removed.
Make PlaceholderGroup immutable, fix addition, add repr
Make escape sequence stack take a default_escape_sequence...

which will be output as a prefix to the output of every 'pop'
Add tests for default formatting, fix usage of default_format and stack
Fix default formats during update and delegation of default formats...

from containers.