Just rediscovered this.

`try.c` contains a prototype new implementation of red-black trees. It's
not finished yet, but it is promising, and the logic of the red-black
balancing algorithm "all came rushing back to me" when I looked at the
code just now.

`try.c.bak` contains a precursor, but it has some different notes in it
I think so I'm preferring to keep it safe in version control.
Add rbtree from eina to the bestiary.

This is a very interesting implementation.

It doesn't use parent links, so it's insert routine manually keeps a
stack of pointers keeping track of the path down to the leaf; this is
fine because red-black trees have a precise depth limit, and so a
(small) hardcoded size can be computed which is impossible to overrun
(the tree would have to have more nodes than the number of addressable
bytes on the machine).

What I find really interesting about this implementation is how the
symmetry is exploited. As it goes down the tree on insert, it stores the
direction with the pointer with the code:

  /* Keep path in stack */
  stack[s++] = (uintptr_t)r | dir;

Then, these direction indicators are used *very aggressively*. The
insertion code is pleasingly short.

Some tripping points:
- Stores the color in a separate field. This is hopelessly put as a
  size-1 bitfield, but still due to alignment it costs an entire
  pointer's worth.
Merge recently uncovered code.

I'd been looking for this; it contains some good stuff.
Add notes on rediscovered code.