Initial support for RSS feed parsing.

Add in initial RSS feed parsing.  Currently transforms a feed into something
I want, and does http fetches.  Otherwise boring initial commit!

Also include initial licence (AGPL) + headers.
Deal with initial connection.

Create system to do the initial connection to the system.  It also sets up
any used buckets appropriately.  Mainly this just involves marking the buckets
as allowing siblings.  Also test for this (requires running riak instance
on default ports).
Implement initial resolve behaviour on feed.

Implement a test set of resolving behaviour on feed.  Mainly, this resolve
the regular feed content so that it matches what was last fetched.  It
doesn't deal with items yet (deleted or not).  Also, add a custom deep
equal function (copied from reflect) that ignores certain feeds.  This is
used to ignore the Model field given from the riak library, as it differs,
but not in a way a test cares about.
Implement an insert merge.  Works over arbitrary arrays.

Implement an insert merge operation, to be used to resolve conflicts on the
feed list.  It takes in pre-sorted lists and merges/de-dups them.  It uses
a set of interfaces so it works on any data structure.  It maps easily to
slices though.
Verify and fix inserting elements that are the same.

There was a missing append when both elements were the same, seemingly the
fuzzer never produced two number that were the same.  Thus explicitly test,
and fix the issue that arose.
Implement resolving of the lists.

Make sure that the lists returned are properly merged.  Also test this condition.
Note that there is a bug in the goriakpbc library that needs to be fixed,
otherwise the test will fail and the system will not work.
Get a slice ops started now, and add a subtract function between slices.

Rename insert_slice_sort.go to slice_ops.go, and have it hold a bunch of
slicish related functions.  Also add a Subtraction function, to do:
a = a - b.  Update necessary interfaces to have a remove at function, and
update implementations of that interface so it works.
Add another test, so that Deleted items are also removed from the general list.

Deleted items shouldn't show up in item keys, otherwise bad things will
happen when the item is kicked out from under it.  Thus when resolving make
sure that holds true.
Stop copying siblings on top of the feed.

Since siblings also have Models, which would then get copied, things might
go horribly wrong.  Thus avoid this by not doing that copy.
Add the necessary handling for items.

Add the code to deal with items.  They now retrieve just fine with conflicts,
or at least they seem to.
Atom feeds set Id instead of Guid, so make sure to use it.

When atom feeds are parsed by the external library, they set the Id
parameter instead of the Guid parameter.  Thus also check it and use it
if set.  Use it in the exact same way as the Guid.
In my custom deep equal, support a custom Equal method interface.

As a special case, if a type has a method like:
func (T) Equal(T) bool
then use it for doing comparisons instead of just using ==.  This is used
for now to have Time ignore location (as I don't care if it matches exactly).
Stop removing the allow multi setting on buckets.

When the test suite is run against a real cluster (invovling multiple nodes),
the changing of the allow multi setting races the gossip protocol to make
the change known.  This causes some expected conflicts to not occur, and thus
break the suite now and again.  Thus just don't do it.  Unfortunately, that
means the cluster isn't left in a pristine condition when the suite is finished.
Optimize the test suite by reusing a connection.

The test suite use to take 5.5 seconds, due to re-establishing a connection
to riak.  Reduce this down by re-using the same connection.  It now runs
in about 1.5 seconds, and talking to riak is much faster now.
When testing the feed attributes, ignore the key lists.

To avoid random failures, assume the resolve function may be given a sibling
with keys.  Since this test doesn't deal with them at all, just ignore the
fields during the comparison.  Proper handling of the fields is handled later.
Worrying about it know is just over reaching.
Inside the key list tests, standardize on what the list should be.

Even though each test is exercising one specific piece of code, ensure that
even if random other lists are merged that the same result occurs.  This
is to reduce random meaningless failures of the suite because of Riak's
eventual consistency getting in the way, especially over networks.
Start testing the RSS field parsing.

Start building an automated test suite for the RSS parsing.  For now, just
verify that a given input matches its output when passed through the xml
parsing.  Generate RSS feeds from json using github.com/gorilla/feeds (which
requires PR #2 to work).  Eventually the same set of feeds will ensure the
full pipeline is working.
Allow multiple strains of feeds.

Allow multiple feed strains.  Also due to this, there is no easy way to find
the maximum number of feeds, so just fail if I can't read the file entirely.
Move the feed structures to the top of their file.

For easy of finding/documentation, move the feed structures to the top
of their file.  No actually change was made.
Add a function to make it easy to add a create ItemKey.

Add a simplistic function to make a new ItemKey.  It basically takes in
the two pieces (the id, and the rawId as a []byte), and joins them together.
Currently doesn't verify that rawId matches any special format.