Make fix_outline always produce the correct final color

Whenever a glyph has a border, the original glyph's own ASS_Image
is applied on top of the border's ASS_Image. Let's mathematically
devise such alpha values for the border image that the resulting
colors exactly match (modulo rounding) the colors produced by a
hypothetical ASS_Image that contains both the glyph and the border.

Let a_i be the opacity of a single pixel within an ASS_Image,
where i is either g for glyph or o for outline (border). Further,
let A_i be the opacity and c_i the color of the entire ASS_Image.

Think of a_i as the _area_ covered by the glyph/border,
measured in pixels. We have 0 <= a_g <= a_o <= 1.
We also have 0 <= A_g, A_o <= 1.

We need a background color. Let's denote it as c_b. The background
color includes any effects from applying the shadow of the glyph.

The final color we want to achieve is:
  * on the area covered by the original glyph,
                                       A_g c_g + (1 - A_g) c_b.
  * on the area covered by the border, A_o c_o + (1 - A_o) c_b.
  * on the remaining area,             c_b.
Averaging the color over the pixel's area gives:
           a_g  (A_g c_g + (1 - A_g) c_b) +
    (a_o - a_g) (A_o c_o + (1 - A_o) c_b) +
      (1 - a_o)  c_b

The color we actually get after blending the border with the
background and then blending the original glyph with the result is:
        (A_g a_g) c_g +
    (1 - A_g a_g) ((A_o a_o) c_o + (1 - A_o a_o) c_b)

We want to replace a_o in the actual color's expression with a
value that makes it match the expected color. Let's call this value
a_o'. Equating both expressions and solving for a_o' gives:
       A_o (c_o - c_b) = 0 and a_o' does not matter
    or A_g a_g = 1 and a_o' does not matter
    or a_o' = (a_o - a_g) / (1 - A_g a_g)

In the A_o (c_o - c_b) = 0 case, we can always pick an a_o' that
satisfies one of the other two conditions. Effectively we can
ignore the first case altogether.

A_g a_g can only equal 1 if A_g = a_g = 1. Since a_g <= a_o <= 1,
a_o must also be 1. As it happens, libass already handles this case
separately: as a precaution, it checks that a_g < a_o and sets a_o'
to zero if this condition fails to hold. This works fine, so let's
retain this behavior.

This commit makes libass use the solution formula from the third
case to calculate a_o'. To enable this, the opacity of the original
glyph is passed to fix_outline and outline_to_bitmap3. Generated
bitmaps depend on it, so glyphs with different primary color alpha
are now distinguished by the bitmap cache. The calculation itself
is performed exactly and rounded correctly (half towards +infinity)
using only integer arithmetic.
Omit fully transparent glyphs from non-opaque-box shadows

If there is an outline around the transparent glyph,
the shadow is supposed to be a copy of this outline.

This completes the fix made in commit f9283004,
which covered the case where there is no outline.

Fixes issue #70.