Rust: exercise of employees and names

To start, I have some general tips. Run your code through rustfmt to get consistent formatting and make code easier to read. Run your code through clippy to get tips on common mistakes (clippy had nothing to say about your code, nice!)

One overall thing I'd suggest is to not be afraid to use a custom type in a case like this. Instead of returning a Result<(String, String), String> where the Err has multiple meanings based on value, just go ahead and make an Enum for your commands. I'll show you this in my final example, along with merging the two command sections (which the exercise is kinda fuzzy on whether it cares which way you do it).

Onto specific things:

You can get an iterator over lines of stdin by .lock().lines(), which can make this simpler, but that's a matter of preference over using read_line. If you are going to use read_line, you might as well reuse your input buffer, since that's the whole point of it taking a buffer as a parameter instead of just returning a String. That way you aren't reallocating each time.

let mut stdin = io::stdin()
let mut input = String::new();
loop {
    input.clear();
    stdin.read_line(&mut input).unwrap();
    // ...
}

dissect_input should take a &str instead of a String, since you only need to view it.

Down in the listing part, you do &command.trim().to_string(), which is unneeded in a few ways. .to_string() takes you from a &str to a String, and then the & brings you right back to a &str, so you could just do command.trim(). Also, you can just bind in the match you already have, like dept => employees.get(dept)

Overall, this is a really good first attempt! It can be hard to first wrap your head around the things that make rust different, like lifetimes and slices, but just getting things working is a great step.

Here's how I might choose to do this exercise.

use std::collections::HashMap;
use std::io;

// required trait for .lines()
use std::io::BufRead;

fn main() {
    let mut employees: HashMap<String, Vec<String>> = HashMap::new();
    let stdin = io::stdin();
    println!("Type 'Add <name> to <department>' to add an employee");
    println!("Type 'List <department>' to list the employees of a department");
    println!("Type 'All' to list all employees by department");
    println!("Type 'Quit' to quit");
    for line in stdin.lock().lines() {
        let input = line.expect("error: unable to read user input");
        match Command::from_input(&input) {
            // or_default is just a convenience, does the same as or_insert_with(Vec::default)
            Some(Command::Add { dept, name }) => employees.entry(dept).or_default().push(name),
            Some(Command::List(dept)) => match employees.get(&dept) {
                Some(names) => {
                    for name in names {
                        println!("{}: {}", dept, name);
                    }
                }
                None => println!("I don't recognize that department!"),
            },
            Some(Command::All) => {
                for (dept, names) in &employees {
                    let mut names = names.clone();
                    names.sort();
                    for name in names {
                        println!("{}: {}", dept, name);
                    }
                }
            }
            Some(Command::Quit) => break,
            // consider using eprintln, which prints to stderr
            None => println!("Input error!"),
        }
    }
    println!("Have a nice day!");
}

enum Command {
    // Using named fields instead of Add(String, String) because dept and name
    // are the same type and could get mixed up.
    Add { dept: String, name: String },
    List(String),
    All,
    Quit,
}

impl Command {
    fn from_input(s: &str) -> Option<Self> {
        let words: Vec<&str> = s.trim().split_whitespace().collect();
        // "Slice destructuring / slice pattern matching" for more info
        match words.as_slice() {
            ["All"] => Some(Command::All),
            ["Quit"] => Some(Command::Quit),
            ["List", dept] => Some(Command::List(dept.to_string())),
            ["Add", name, "to", dept] => Some(Command::Add {
                dept: dept.to_string(),
                name: name.to_string(),
            }),
            _ => None,
        }
    }
}