Reorganized modules, made rules a separate struct

Rules are now a separate struct, and the `rules` member of
`settings::Settings` is now a `Vec<settings::rule::Rule`.

Several elements were made private, now can be accessed through
dedicated methods

src/settings/rule/regex_wrapper.rs

@@ -0,0 +1,77 @@
+use std::{fmt, ops};
+
+#[derive(Clone, Debug)]
+pub struct Regex(regex::Regex);
+
+impl Regex {
+    pub fn new(s: &str) -> Self {
+        Self(regex::Regex::new(s).unwrap())
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+
+    pub fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+use std::hash::{Hash, Hasher};
+impl Hash for Regex {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.as_str().hash(state);
+    }
+}
+
+impl ops::Deref for Regex {
+    type Target = regex::Regex;
+    fn deref(&self) -> &regex::Regex {
+        &self.0
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Regex {
+    fn deserialize<D>(de: D) -> Result<Regex, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::{Error, Visitor};
+
+        struct RegexVisitor;
+
+        impl<'de> Visitor<'de> for RegexVisitor {
+            type Value = Regex;
+
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("a regular expression pattern")
+            }
+
+            fn visit_str<E: Error>(self, v: &str) -> Result<Regex, E> {
+                regex::Regex::new(v)
+                    .map(Regex)
+                    .map_err(|err| E::custom(err.to_string()))
+            }
+        }
+
+        de.deserialize_str(RegexVisitor)
+    }
+}
+
+use serde::{Serialize, Serializer};
+impl Serialize for Regex {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.0.as_str())
+    }
+}
+
+impl PartialEq for Regex {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_string() == other.0.to_string()
+    }
+}
+
+impl Eq for Regex {}