Add a protected Surface constructor that accepts an SDL_Surface
Refactor most of display::Surface into display::LegacySurface

This makes it clear which display operations depend on pixel-level
access and 8-bit palettes, and which operations do not.
Make legacy screen accesses explicit

Graphics::screen() now returns a Surface, on which we can draw and
such, but not twiddle directly. Graphics::legacyScreen() returns the
underlying LegacySurface, permitting direct pixel access, and allowing
us to identify and refactor legacy accesses.
Implement clearing in truecolor terms
Push global palette onto LegacySurface

LegacySurface is a 2D area associated with a palette. We use the
global LegacySurface for pixel access, but prior to this changeset,
we used a separate palette attached to the Graphics object rather
than the one internal to the legacyScreen() object.
Fix updatePalette()

We should set the SDL palette to the object-wide palette, rather than
setting it to a just-initialized-with-zeros local.
Remove unused palette pointer from fading functions
Make native palettes autoriative

This changeset retires SDLPalette and LegacyPalette, since both of
those store palettes in arbitrary local formats that have to be copied.
Instead, it provides us with SDLPaletteWrapper, allowing access to an
underlying SDL_Palette *, and it modifies Surfaces as appropriate.

Some of the code requires a pal[768] array, so some allowance must be
made. Thus, display::AutoPal: it get()s a PaletteInterface into a
local pal[768] array when constructed, and it set()s that array on
destruction. It's intended to be used in small scopes as a transition
measure.
Fix port transparency

Now that SDL is aware of palettes, LegacySurface::copyFrom() and
copyTo() require palettes to be set correctly even on temporary
surfaces.
Add a checkPaletteCompatibility() method

This ensures that we don't do anything stupid with surfaces, like
trying to copy to an 8bpp surface with an all-black palette.
Twiddle draw() signature

It now accepts either a boost::shared_ptr<Surface> or a Surface&. Both
are const, as drawing never modifies the source surface. There's also a
4-arg version for blitting a subset of the source surface, which is
useful in some downstream code.
Move Surface operation enums to LegacySurface

Surface doesn't know anything about them anyway.
Add LegacySurface::setTransparentColor()

Now that we're using SDL blitting operations, we can take advantage of
semi-transparent surfaces. This should result in less maskCopy() usage,
and fewer temporary surfaces in general.