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.
Have LegacySurface track its own palette validity

Accessing the palette() will cause hasValidPalette() to be set. Any
drawing operation between two LegacySurfaces will now compare palettes:
if both are valid, it ensures equality (tripping an assertion on
failure), and if only one is valid, it copies the palette the other way.

This allows us to support the common pattern of LegacySurfaces for
compositing without discarding the "every surface knows its palette"
rule. This could be considered cheating, but hey.
Add detail to exception messages
Add HardwareButtons class

This class displays a strip of buttons representing hardware
groups. The constructor accepts a y-coordinate and player index, and
it loads the relevant image. Calling drawButtons() redraws the buttons
and their beveled borders, optionally highlighting one of the groups.
Refactor hardware button displays to use HardwareButtons

This commit also clarifies a few functions in intel.cpp, as well
as streamlining away the R&D men display.
aipur.cpp now requires a graphics #include due to modified packing
Expose the palette for PalettizedSurfaces
Eliminate prefs.but

The preferences code still manipulates vhptr and such, but it's
slightly less gross this way, so hey.