Found an icky buck where an image that was in the process of being
sent asynchronously was modified to have zero dimensions to signal
that it was empty.

When I last looked at the code, I thought maybe I should have
computed the image holder by the partition_index and dest_partner.
I guess I should have.

This basically happens when the local process has no image due to a
non-split round.

Instead setting the geometry bounds so that it was not projected and
IceT's reduce strategy would drop it, I just made the bounds really
large.  I am stupid.

Have the processes with the lower ranks not participate instead of
the higher ranks.  The point is so that the group ranks do not match
the actual ranks.

You still need this index in the receiver to know what order to
composite images.

This test is catching a radix-k bug concerning no-split rounds.

Previously when computing partition indices, the decision of split
versus gather was based on comparing the number of partitions to create
to the max number of splits.  In some circumstances, this could mean
a round gathers (and some processes drop out) and in a later round
splits happen.  This really complicates the indexing and was causing
errors.  Fix the problem by disallowing any splits after encountering
a round where splits should not take place.

Radix-k will only create ICET_MAX_IMAGE_SPLIT partitions.  After that
it will simply collect images and let other processes go idle.

There was this stupid hackish thing I was doing when grapping the image
buffer storing the last render.  Instead of getting it by allocating
the buffer again, store the pointer in a different state variable.  Now
you only call allocate when you need a new buffer.

With this change, you only call the state buffer allocate functions when
you want a fresh buffer.  In debug mode, fill the values with 0xDC to
make it more obvious when I create an error when reusing buffers.

Does not do anything yet.

The gcc compiler wants to optimize a conditional that is always true,
but only if we assume that there is no signed overflow.  (That is,
there are no negitive numbers.)  It happens to be true wtih the numbers
I give, so do a bunch of casts to tell the compiler that.

This was the (hopefully) one place where the radix-k code was still
using the whole group for determing splits rather than the largest
power of 2 size.

In most places malloc is called, check to make sure that the returned
pointer is not null, and emit an out of memory error if it is.

Found several places where free was not always called for all allocated
memory.

When possible, remove direct calls to malloc in the code and replace
with the state variable memory management.

Previously, the strategy always returned an image for the display
tile, and the calling icetDrawFrame checked the size of that returned
image against the expected size of the display.  With the uncollected
option, any process can return an image for any tile.  Thus, we need
to check against the valid tile rather than the display tile.  If
collection is on, also check to make sure the valid tile is the same
as the display tile.

There was too much regularity in the colors of the partitions.  These
changes space out the colors differently so that it looks more scattered
and random (although it is not really).