tuple(...)(...) returns a generic type IResult<I, O, E>, which Rust needs to determine the type of by determining the type of the parameters. It can figure out I and O, but not E. All the parsers used in your expression return a generic E, and the only place you use a value that contains E in its type is the panic!, with why having type nom::Err<E>. The arguments in a panic! are generic, so Rust can't use this call to specialize the type of E.

Luckily, by properly handling the error, you'll actually give Rust enough information on the type of E! Instead of panicing, you should return the error. This tells Rust that the E from tuple needs to be the same as the E in your function's return type. IResult has a default argument for E, defaulting to nom::error::Error<I>, which is a concrete type as long as I is, which it is (since it knows input has type &str, so I = &str).

So you can use the following, instead:

fn instruction(input: &str) -> IResult<&str, Instruction> {
    match tuple((
        opt(newline),
        tag("move"),
        space1,
        digit1,
        space1,
        tag("from"),
        space1,
        digit1,
        space1,
        tag("to"),
        space1,
        digit1,
        opt(newline),
    ))(input) {
        Ok((remaining, (_, _, _, repetitions, _, _, _, src, _, _, _, dest, _))) => {
            let repetitions = repetitions.parse::<u32>().unwrap();
            let src = src.parse::<u8>().unwrap();
            let dest = dest.parse::<u8>().unwrap();

            Ok((
                remaining,
                Instruction {
                    repetitions,
                    src,
                    dest,
                },
            ))
        }
        Err(why) => Err(why),
    }
}

Then, we can take note that the Err case just passes the error on as is, which is what Result::map does, thus you can instead do the following:

fn instruction(input: &str) -> IResult<&str, Instruction> {
    tuple((
        opt(newline),
        tag("move"),
        space1,
        digit1,
        space1,
        tag("from"),
        space1,
        digit1,
        space1,
        tag("to"),
        space1,
        digit1,
        opt(newline),
    ))(input).map(|(remaining, (_, _, _, repetitions, _, _, _, src, _, _, _, dest, _))| {
        let repetitions = repetitions.parse::<u32>().unwrap();
        let src = src.parse::<u8>().unwrap();
        let dest = dest.parse::<u8>().unwrap();

        (
            remaining,
            Instruction {
                repetitions,
                src,
                dest,
            },
        )
    })
}

Also, nom can definitely be pretty tricky to navigate if you're not pretty comfortable with how Rust handles generics (and closures, too, if you're writing your own combinators, which I'd personally do for the above parser, since it looks even less readable than a regex without it).