Switch to using serde for deserialization

The current build system is rudimentary, incomplete, and rigid, offering
little in the way of customizing decoding options.

To solve this, switch to using serde-derive with custom Deserialization
implementations. This allows very simple deserialization when special
logic does not need to be applied, yet allows us to implement our own
deserialization logic when required.

The problem with the build system was that it built enums and structs
from YAML files. This is not so good, because it requires creating a
custom build system (which was rudimentary), creating "special struct
configs" when logic needed to be ever so slightly extended (rigid), and
if special logic needed to be applied, a custom deserialization method
would have been needed to be made anyway (incomplete).

To solve this, switch to serde-derive and implementing Deserialize
ourselves where required. This reduces YAML definitions that might
look like:

```yaml
---
name: Group
description: >
  A group channel, potentially including other users, separate from a [`Guild`].
    [`Guild`]: struct.Guild.html
fields:
  - name: channel_id
    description: The Id of the group channel.
    from: id
    type: ChannelId
  - name: icon
    description: The optional icon of the group channel.
    optional: true
    type: string
  - name: last_message_id
    description: The Id of the last message sent.
    optional: true
    type: MessageId
  - name: last_pin_timestamp
    description: Timestamp of the latest pinned message.
    optional: true
    type: string
  - name: name
    description: The name of the group channel.
    optional: true
    type: string
  - name: owner_id
    description: The Id of the group channel creator.
    type: UserId
  - name: recipients
    description: Group channel's members.
    custom: decode_users
    t: UserId, Arc<RwLock<User>>
    type: hashmap
```

to:

```rs
/// A group channel - potentially including other [`User`]s - separate from a
/// [`Guild`].
///
/// [`Guild`]: struct.Guild.html
/// [`User`]: struct.User.html
pub struct Group {
    /// The Id of the group channel.
    #[serde(rename="id")]
    pub channel_id: ChannelId,
    /// The optional icon of the group channel.
    pub icon: Option<String>,
    /// The Id of the last message sent.
    pub last_message_id: Option<MessageId>,
    /// Timestamp of the latest pinned message.
    pub last_pin_timestamp: Option<String>,
    /// The name of the group channel.
    pub name: Option<String>,
    /// The Id of the group owner.
    pub owner_id: UserId,
    /// A map of the group's recipients.
    #[serde(deserialize_with="deserialize_users")]
    pub recipients: HashMap<UserId, Arc<RwLock<User>>>,
}
```

This is much simpler and does not have as much boilerplate.

There should not be any backwards incompatible changes other than the
old, public - yet undocumented (and hidden from documentation) - decode
methods being removed. Due to the nature of this commit, field names may
be incorrect, and will need to be corrected as deserialization errors
are found.

1 files changed, 46 insertions, 0 deletions

diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 77d84e1..d4e1da8 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -9,6 +9,52 @@ use ::internal::prelude::*;
 #[cfg(feature="cache")]
 use ::utils::builder::EditRole;
 
+/// Information about a role within a guild. A role represents a set of
+/// permissions, and can be attached to one or multiple users. A role has
+/// various miscellaneous configurations, such as being assigned a colour. Roles
+/// are unique per guild and do not cross over to other guilds in any way, and
+/// can have channel-specific permission overrides in addition to guild-level
+/// permissions.
+#[derive(Clone, Debug, Deserialize)]
+pub struct Role {
+    /// The Id of the role. Can be used to calculate the role's creation date.
+    pub id: RoleId,
+    /// The colour of the role. This is an ergonomic representation of the inner
+    /// value.
+    #[serde(rename="color")]
+    pub colour: Colour,
+    /// Indicator of whether the role is pinned above lesser roles.
+    ///
+    /// In the client, this causes [`Member`]s in the role to be seen above
+    /// those in roles with a lower [`position`].
+    ///
+    /// [`Member`]: struct.Member.html
+    /// [`position`]: #structfield.position
+    pub hoist: bool,
+    /// Indicator of whether the role is managed by an integration service.
+    pub managed: bool,
+    /// Indicator of whether the role can be mentioned, similar to mentioning a
+    /// specific member or `@everyone`.
+    ///
+    /// Only members of the role will be notified if a role is mentioned with
+    /// this set to `true`.
+    #[serde(default)]
+    pub mentionable: bool,
+    /// The name of the role.
+    pub name: String,
+    /// A set of permissions that the role has been assigned.
+    ///
+    /// See the [`permissions`] module for more information.
+    ///
+    /// [`permissions`]: permissions/index.html
+    pub permissions: Permissions,
+    /// The role's position in the position list. Roles are considered higher in
+    /// hierarchy if their position is higher.
+    ///
+    /// The `@everyone` role is usually either `-1` or `0`.
+    pub position: i64,
+}
+
 impl Role {
     /// Deletes the role.
     ///