Internal vs. exported function lifetimes

Here is another "works on Polonius" case, but I'm hoping I can work-around this in vanilla Rust.

The essence here is that I have a complicated explicit lifetime relationship. (not actually that complicated - two mutable inputs, and the output can borrow from either)

The issue seems to be that my 'out lifetime needs to last throughout the whole function. Which ends up tying up an input variable so I can't use it for subsequent access, even though it should be ok to terminate and subsequently restart the 'out lifetime.

struct Node(usize);

impl Node {
    pub fn get_mut<'a, 'b, 'slice, 'out>(&'a mut self, subtrees: &'slice mut[&'b mut Self]) -> Option<&'out mut Self>
    where 'a: 'out, 'slice: 'out, 'b: 'out
    {
        let subtree_idx: usize = {
            if let Some(inner_val) = self.try_inner_mut(subtrees) {
                return Some(inner_val);
            } else {
                0
            }
        };
        
        //Ideally we could end the `'out` lifetime here and try again, since we don't have any other borrows alive here.

        Some(*subtrees.get_mut(subtree_idx).unwrap())
    }
    
    fn try_inner_mut<'a, 'b, 'slice, 'out>(&'a mut self, _subtrees: &'slice mut[&'b mut Self]) -> Option<&'out mut Self>
    where 'a: 'out, 'b: 'out, 'slice: 'out
    {
        Some(self)
    }
}

fn main() {
    let mut zero = Node(0 as usize);
    let mut one = Node(1 as usize);
    let mut two = Node(2 as usize);
    let mut slice = [&mut one, &mut two];
    zero.get_mut(&mut slice).unwrap();
    slice.get_mut(0);
}

Any ideas / insights are appreciated. Thank you.