Large refactor. Use rayon, 10X performance boost

Code changes:
Removed ignore & channel crates. Using a single reciever thread to build
a hashmap to prevend duplicate inodes being reported gave a severe
performance penalty

Using rayon crate with some hand crafted file traversal has improved
performance aprox 10X

Behaviour changes:

Removed parameter 'limit by filesystem' - don't think this is used, and
I only added it as it was easy to add with the ignore crate.

Sym links will now not appear in the output tree unless using '-s'
'apparent-size' flag

Change behaviour of multiple args so that it unifies them and
compares them under one tree instead of treating them
individually: https://github.com/bootandy/dust/issues/136

src/filter.rs

@@ -0,0 +1,104 @@
+use crate::display_node::DisplayNode;
+use crate::node::Node;
+use std::collections::BinaryHeap;
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+pub fn get_by_depth(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
+    if top_level_nodes.is_empty() {
+        // perhaps change this, bring back Error object?
+        return None;
+    }
+    let root = get_new_root(top_level_nodes);
+    Some(build_by_depth(&root, n - 1))
+}
+
+pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
+    if top_level_nodes.is_empty() {
+        // perhaps change this, bring back Error object?
+        return None;
+    }
+
+    let mut heap = BinaryHeap::new();
+    let number_top_level_nodes = top_level_nodes.len();
+    let root = get_new_root(top_level_nodes);
+
+    root.children.iter().for_each(|c| heap.push(c));
+
+    let mut allowed_nodes = HashSet::new();
+    allowed_nodes.insert(&root.name);
+
+    for _ in number_top_level_nodes..n {
+        let line = heap.pop();
+        match line {
+            Some(line) => {
+                line.children.iter().for_each(|c| heap.push(c));
+                allowed_nodes.insert(&line.name);
+            }
+            None => break,
+        }
+    }
+    recursive_rebuilder(&allowed_nodes, &root)
+}
+
+fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
+    let new_children = {
+        if depth == 0 {
+            vec![]
+        } else {
+            let mut new_children: Vec<_> = node
+                .children
+                .iter()
+                .map(|c| build_by_depth(c, depth - 1))
+                .collect();
+            new_children.sort();
+            new_children.reverse();
+            new_children
+        }
+    };
+
+    DisplayNode {
+        name: node.name.clone(),
+        size: node.size,
+        children: new_children,
+    }
+}
+
+fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
+    if top_level_nodes.len() > 1 {
+        let total_size = top_level_nodes.iter().map(|node| node.size).sum();
+        Node {
+            name: PathBuf::from("(total)"),
+            size: total_size,
+            children: top_level_nodes,
+            inode_device: None,
+        }
+    } else {
+        top_level_nodes.into_iter().next().unwrap()
+    }
+}
+
+fn recursive_rebuilder<'a>(
+    allowed_nodes: &'a HashSet<&PathBuf>,
+    current: &Node,
+) -> Option<DisplayNode> {
+    let mut new_children: Vec<_> = current
+        .children
+        .iter()
+        .filter_map(|c| {
+            if allowed_nodes.contains(&c.name) {
+                recursive_rebuilder(allowed_nodes, c)
+            } else {
+                None
+            }
+        })
+        .collect();
+    new_children.sort();
+    new_children.reverse();
+    let newnode = DisplayNode {
+        name: current.name.clone(),
+        size: current.size,
+        children: new_children,
+    };
+    Some(newnode)
+}