Operation: buffer

The buffer operation is an operation which allows you to buffer incoming events into one or more buffers. Depending on their purpose, these buffers can be emitted to an `Observer` when needed. In essence this means that events are collected and propagated to the `Observer` in batches. The [original issue](https://github.com/Netflix/RxJava/issues/16), which this pull request addresses, mentions a total of 10 variations on this operator. This pull request contains code which supports all of them.

![buffer](https://f.cloud.github.com/assets/4491168/731348/2f076cc8-e269-11e2-8fa8-e798f04f2f3c.png)

The 10 variations which exist in Rx .Net, can be subdivided into two categories: single and multi buffers. With single buffers, only one buffer at any time is actively collecting incoming events, whereas with multi buffers, multiple buffers are actively collecting incoming events. In the first case the `Observer` will receive every original event only once in one buffer, whereas in the latter case, the `Observer` will receive every original event zero or more times.

### Single buffers

##### buffer(bufferClosingSelector)
The bufferClosingSelector parameter is a `Func0<Observable<BufferClosing>>`. It uses to `Func0` object to construct an `Observable` which produces a `BufferClosing` object. Once this object has been produced by the `Observable` the currently active buffer will be closed and emitted to the `Observer`. At the same time a new buffer will be created which will start recording incoming events. 

##### buffer(count)
This operator closes and emits the current buffer after counting a certain amount of received events. At the same time it will create a new buffer which will start recording incoming events. One example would be `buffer(2)`, which with the following input: `[0, 1, 2, 3, 4, 5]` will output the following buffers: `[0, 1], [2, 3], [4, 5]`.

##### buffer(timespan)
This operator closes and emits the current buffer after a certain amount of time has elapsed. At the same time it will create a new buffer which will start recording incoming events.

##### buffer(timespan, scheduler)
Same as previous operator, but now with a custom scheduler.

##### buffer(timespan, count)
This operator closes and emits the current buffer after counting a certain amount of received events or after a certain amount of time has elapsed. At the same time it will create a new buffer which will start recording incoming events.

##### buffer(timespan, count, scheduler)
Same as previous operator, but now with a custom scheduler.

### Multiple buffers

##### buffer(count, skip)
This operator will create a new buffer after it has received 'skip' amount of events. Each buffer will be closed once it has reached a capacity of '[count'. One example would be `buffer(3, 1)`, which with the following input: `0, 1, 2, 3, 4, 5]`, will output the following buffers: `[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]`.

##### buffer(bufferOpenings, bufferClosingSelector)
This operator takes two parameters: an `Observable<BufferOpening>` and a `Func1<BufferOpening, Observable<BufferClosing>>`. The first parameter determines when buffers are created. The second parameter determines when the buffers are closed. Every time a `BufferOpening` object is received from the `Observable` a new buffer is created. The received `BufferOpening` object is fed into the second parameter which yields an `Observable<BufferClosing>` object. When this `Observable` produces a `BufferClosing` object, the associated buffer is closed and emitted.

##### buffer(timespan, timeshift)
This operator is very similar to `buffer(count, skip)`, but in stead of counting events, it's based on time. The `timeshift` period defines how often a new buffer will be created. The `timespan` period defines the period between buffer construction and buffer emission.

##### buffer(timespan, timeshift, scheduler)
Same as previous operator, but now with a custom scheduler.

As always, **feedback is welcome!**