Update CONTRIBUTING.md

Add more information from the Spring Framework document on maintaining a linear history as well as some code-style information
Fix link in CONTRIBUTING.md
LMAX Disruptor RingBuffer-based channel

Add a new RingBufferChannel that uses a RingBuffer from the LMAX
Disruptor to store messages that are sent to the channel. Messages
are consumed from the RingBuffer on a separate thread which
dispatches them using the channel's MessageDispatcher.

This channel is somewhat similar to an ExecutorChannel in that it
provides a mechanism by which the processing of a message can be
passed from one thread to another. However, in this case, the use of a
RingBuffer allows the passing of the message from one thread to
another to be performed without locking. Also, the RingBufferChannel
only uses a single thread to consume messages from the RingBuffer.
BatchingMessageHandler that uses LMAX's RingBuffer

A BatchingMessageHandler can be used to collect messages into batches
that are of a configurable size. Each batch is released once the
batch size has been reached, or the ring buffer is empty. When a batch
is released, a message containing a list of all of the batched
message's payloads is sent to the handler's output channel.
Use a separate strategy for creating batch message

Update batching message handler to use a separate MessageBatcher to
turn the batch's list of messages into a single message that represents
the batch. A default implementation that creates a message that has a
list of all of the messages' payloads as its payload is provided.

In addition to this, a reusable HeaderMerger abstraction has been
created.  A HeaderMerger is typically used by a MessageBatcher to merge
together the headers of the messages in the batch. Three implementations
are provided, ConflictDiscardingHeaderMerger, FirstWinsHeaderMerger, and
LastWinsHeaderMerger.

ConflictDiscardingHeaderMerger provides the same logic as was used in 
AbstractAggregatingMessageGroupProcessor. This class has been updated
to use the new header merger, while still allowing the behaviour to be
overridden by subclasses.
Add XML namespace support for ring buffer channel

Ring buffer channels can now be easily configured using the XML
namespace. For example:

<ring-buffer-channel id="ringBufferChannel"/>
<ring-buffer-channel id="ringBufferChannel" size="4096"/>

A custom error handler can also be specified, along with dispatcher
configuration. The task-executor attribute of the dispatcher
configuration is not supported by a ring buffer channel. Currently,
an attempt to use it will cause a failure during parsing of the 
application context.

To support the namespace, a number of setter methods have been added
to RingBufferChannel to make it more configurable.
Implement SmartLifecycle rather than Lifecycle

Update BatchingMessageHandler and RingBufferChannel to implement
SmartLifecycle rather than Lifecycle. This ensures that their lifecycle
is managed as part of application context start and stop processing.

The start and stop methods have been improved to ensure that an already
started or stopped component is not started or stopped again.

The javadoc has been polished.
A RingBuffer-based TaskExecutor

An implementation of TaskExecutor that uses an LMAX Disruptor RingBuffer
to queue tasks that are awaiting execution. A single thread is used to
execute tasks. Provides a high performance non-blocking mechanism for
handing off execution of a task to another thread.
Block thread or reject task when buffer is full

Prior to this commit, an attempt to execute a task when the ring buffer
was full would result in a TaskRejectedException being thrown. This
commit enhances RingBufferTaskExecutor so that its behavior in this
situation is configurable. It can either be configured to throw a
TaskRejectedException or to block the calling thread until there's
space in the ring buffer for the new task.