make Configuration::to_string() deterministic

tests assume that the order of elements is deterministic. Without this
you can be unlucky and get a tests failure like:

```
assertion failed: `(left == right)`'
  left: `"voters=(2 3 1)&&(1) autoleave\n1: StateProbe match=0 next=0\n2: StateProbe match=0 next=1\n3: StateProbe match=0 next=1\n"`
 right: `"voters=(1 2 3)&&(1) autoleave\n1: StateProbe match=0 next=0\n2: StateProbe match=0 next=1\n3: StateProbe match=0 next=1\n"`

Differences (-left|+right):
-voters=(2 3 1)&&(1) autoleave
+voters=(1 2 3)&&(1) autoleave
 1: StateProbe match=0 next=0
 2: StateProbe match=0 next=1
 3: StateProbe match=0 next=1
```

Signed-off-by: Guillaume Girol <guillaume.girol@rubycat.eu>

Author: ggirol-rc

src/tracker.rs

@@ -92,37 +92,39 @@ pub struct Configuration {
 #[cfg(test)]
 impl std::fmt::Display for Configuration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fn iter_to_sorted_string(iter: impl Iterator<Item = impl ToString + Ord>) -> String {
+            iter.sorted()
+                .map(|x| x.to_string())
+                .collect::<Vec<String>>()
+                .join(" ")
+        }
         use itertools::Itertools;
         if self.voters.outgoing.is_empty() {
-            write!(f, "voters={}", self.voters.incoming)?
+            write!(
+                f,
+                "voters=({})",
+                iter_to_sorted_string(self.voters.incoming.iter())
+            )?
         } else {
             write!(
                 f,
-                "voters={}&&{}",
-                self.voters.incoming, self.voters.outgoing
+                "voters=({})&&({})",
+                iter_to_sorted_string(self.voters.incoming.iter()),
+                iter_to_sorted_string(self.voters.outgoing.iter())
             )?
         }
         if !self.learners.is_empty() {
             write!(
                 f,
                 " learners=({})",
-                self.learners
-                    .iter()
-                    .sorted_by(|&a, &b| a.cmp(b))
-                    .map(|x| x.to_string())
-                    .collect::<Vec<String>>()
-                    .join(" ")
+                iter_to_sorted_string(self.learners.iter())
             )?
         }
         if !self.learners_next.is_empty() {
             write!(
                 f,
                 " learners_next=({})",
-                self.learners_next
-                    .iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<String>>()
-                    .join(" ")
+                iter_to_sorted_string(self.learners_next.iter())
             )?
         }
         if self.auto_leave {