`irrefutable_let_patterns` should not lint at the start of an `else if` let-chain

[Jarcho]

The following triggers irrefutable_let_patterns:

fn expensive() -> u32 {
    0
}

fn option(x: u32) -> Option<u32> {
    Some(x)
}

fn f(x: bool) {
    if x {
        // something
    } else if let foo = expensive()
        && let Some(bar) = option(foo)
    {
        // use `foo` and `bar`
    } else {
        // something
    }
}

Though let foo = expensive() is irrefutable, it would add an extra layer of nesting to move it into a regular let statement. e.g.

if x {
    // something
} else {
    let foo = expensive()
    if let Some(bar) = option(foo) {
        // use `foo` and `bar`
    } else {
        // something
    }
}

[workingjubilee]

Sorry for the sudden retitling, I noticed your example uses #![feature(let_chains)] and I'm not sure if this combination of events can occur without it.

[Jarcho]

I was actually about to change that. I realized after submitting this that the lint applies to all let expression, not just let chains.