Change pixel processing to use integer arithmetic.

Flipper uses fixed-point arithmetic for most of the pixel-processing calculations, while Dolphin currently uses floating-point arithmetic all over the place. There are three major issues with this:
* integer overflows need to be emulated with cumbersome hacks. E.g. `value - 2.0 * round(0.5 * value * (256.0/255.0)) * (255.0/256.0)` is the code theoretically required to emulate overflows of unsigned 8 bit integers. With this branch, we can just do "value & 0xFF" instead.
* integers don't have a fractional part, while floats of course do: This is causing huge issues with the alpha testing code. E.g. when the alpha test only succeeds if the test value is EQUAL to the reference value, the current Dolphin code hence checks if the test value is "close enough"  to the reference value (with a very badly defined sense of "closeness"). This branch can use the == operator for this just fine.
* 32 bit floats only have 23 bits of mantissa, hence they cannot be used to describe 24 bit integers properly.

This branch attempts to fix all of these issues by using actual integer arithmetic in our shaders instead of floating-point arithmetic. The most important implications of this are:
* Vastly improved compatibility: More than 20 games have been reported to be in some way fixed - it's expected that a much larger number of games is in some way affected. Usually the previous code had small mistakes which only showed up slightly (e.g. the goop bubbles in Super Mario Sunshine), other issues were very noticeable (e.g. the pink water highlights in Zelda WW) but harmless, and in quite a few cases objects just completely disappeared (e.g. due to the alpha testing issues pointed out above).
* Vastly cleaner code. This is because we don't have to use the incredibly confusing code required to emulate integer overflows with floats anymore. Additionally, a lot of magic numbers which were required for proper normalization before are no longer needed, or at least make actual sense now (e.g. the magic numbers used for calculating the texture coordinate output of indirect tev stages were just plain wrong before).
* Decreased performance: Integers have a small performance penalty compared to floats (tl;dr; GPUs use the same ALUs for both, hence ALUs sometimes need to be double-pumped for proper integer functionality) and hence this branch slows down performance quite a bit. The penalty scales with the IR, so hopefully the slowdown is not too dramatic at native resolution. (Note that this slowdown is only partially due to the reduced integer performance, it's also caused by the more accurate implementation - hence a "floating point" version of this branch would've seen a similar slowdown)
* Regressions: There is a very small number of known regressions in this branch. First, the Simpsons ( http://code.google.com/p/dolphin-emu/issues/detail?id=4570 ) is completely broken now (more consistent with the software renderer though, so I'd guess we're still lacking understanding of hardware there). Second, regressions in the games NBA Live 2005/2006 have been reported where the floor is very glitchy (making that game unbearable to play). Another game has been reported to be broken slightly, but I already debugged the issue and found it to suffer from the same issue as NBA live. Something is still wrong about the way we perform lighting calculations, but I couldn't figure out what it is. Nevertheless, I consider the number of fixes in this branch to clearly outweigh these regressions.

The pipeline stages affected by this change are:
* The whole tev pipeline: inputs and outputs of color combiners in direct stages; calculated texture coordinates from the indirect stages; konstant colors (sic); alpha bump values; ...
* alpha testing (which uses the tev output as its input)
* lighting: Materials and calculated color values are integers now. 
* ConstantManager: Most of the pixel shader inputs are integers now.
* z textures: depth is converted to int, then z textures are applied, then it's converted back to float.
* fog: fog color is integer now
* probably a few other things that I just missed

I hope the code is clear enough for everyone to make sense out of it. I fear actual understanding of it requires understanding of the Flipper GPU, but I'll gladly explain any questions about it.

NOTE: Please don't merge this branch until I give a green light. A blog article is still being worked on, and we want to publish that one roughly at the same time this branch gets merged.