[B+C] Add API to use 1.7 chat features. Adds BUKKIT-5245

##### The Issue:
There are currently no easy way to use the new chat features introduced in 1.7.

##### Justification for this PR:
As said before, there are currently no way (except from directly using the ``/tellraw`` command and passing your own generated json to it) to use the 1.7 chat features.

##### PR Breakdown:
This PR adds a builder interface based on a ``RichMessage`` to which you append ``RichMessagePart``s to build a rich chat message containing (or not):
* a multi-color text, an LocalizedText, an ``ItemStack`` name or an ``Achievement`` name ;
* an optional hoverable (showing a multi-color multi-line text, an ``ItemStack`` or an ``Achievement``) ;
* an optional clickable (executing commands / sending chat message, proposing commands / proposing chat message, or opening urls (actually opens the prompt)).

These messages handle colors and formatting using ChatColor just like standard messages, internally using the existing algorithm built by the great @mbax.

Example LocalizedText:
```java
new LocalizedText("commands.scoreboard.players.reset.success", "Notch")
```

Many (**many**) shortcuts have been added to RichMessage to make it easier to append specific elements, see RichMessage constructors, append methods and insert methods.

``RichMessage`` and ``RichMessagePart`` are ``ConfigurationSerializable`` making it easy to save and load them from a config file.

This PR also adds methods to ``Player`` to send a ``RichMessage`` and two methods to ``Server`` and ``Bukkit`` to broadcast a ``RichMessage``. Those methods are mapped on the standards String methods.

Usage examples can be found [in the TestPlugin after this line](https://github.com/Ribesg/TestPlugin/blob/BUKKIT-5245/src/main/java/fr/ribesg/bukkit/testplugin/TestCommandExecutor.java#L63). You can get builds of all of this and test it yourself using the link below.

##### Testing Results and Materials:
[Test Plugin Source](https://github.com/Ribesg/TestPlugin/tree/BUKKIT-5245)
Build everything yourself to test it as we're not allowed to link CB builds here.

##### Relevant PR(s):
B-1065 - https://github.com/Bukkit/Bukkit/pull/1065 - Associated Bukkit PR

##### JIRA Ticket:
BUKKIT-5245 - https://bukkit.atlassian.net/browse/BUKKIT-5245

##### Authors
* @bendem did a lot of things (Mostly Bukkit part)
* @Ribesg did a lot of other things (CB part and Bukkit part)
* @ST-DDT did the Javadocs for multiple Bukkit files
I guess we should thing of possible scenarios to explain our decision.

Here are a few scenarios i can thing of:

1)
````java
Bukkit.sendBroadcast(someMessage);
````
or
````java
for (Player plr : myPlayers) {
    player.sendRichMessage(someMessage);
}
````

2)
````java
````java
for (Player plr : myPlayers) {
    player.sendRichMessage(someMessage);
    player.sendRichMessage(someMessage2);
}
````
A) As method local variable
B) As static/cached field

Solution single instance cache:
1 with A) convert the message every execution send it to all, good speed (t * m), best memory (1)
1 with B) convert the message every execution send it to all, good speed (t * m), best memory (1)
(expecting other messages send between executions)
2 with A) convert the message every execution for all players send it to all, worst speed (t * p * m), best memory (1)
2 with B) convert the message every execution for all players send it to all, worst speed (t * p * m), best memory (1)

Solution WeakHashMap cache:
1 with A) convert the message every execution send it to all, good speed (t  * m), best memory (1)
1 with B) convert the message only once, best speed (m), good memory (n)
(expecting other messages send between executions)
2 with A) convert the message every execution send it to all, good speed (t * m), good memory(m)
2 with B) convert the message once send it to all, best speed(m), good memory(n)

t = number of executions
p = number of player
m = number of different messages send serial
n = number of distinct cached messages

(Hope i didn't miss anything)

Another thing is:
If we use ````WeakHashMap```` the performance impact should be relatively low, because the ````HashMap```` uses the ````hashCode()```` method, which is used for the single instance cache as well. (if implemented)
The ````hashCode()```` is quite expensive due to recursion through all elements.