I started coding a Linked List in rust just for practice and to learn about ownership and borrowing but I have encountered a problem in the pop_back function when I am trying to update the current pointer. Any ideas?

I have tried reading the compiler message telling me a missmatched types error but I still do not know how to solve the Problem

#[derive(Clone)]
struct Node<T> {
    val: T,
    next: Option<Box<Node<T>>>,
}

struct LinkedList<T> {
    head: Option<Box<Node<T>>>,
    tail: Option<Box<Node<T>>>,
    len: u64,
}


impl<T: Clone> Node<T> {
    pub fn new(data: T) -> Self {
        Node {
            val: data,
            next: None,
        }
    }
}

impl<T: Clone> LinkedList<T> {
    pub fn new() -> Self {
        LinkedList {
            head: None,
            tail: None,
            len: 0,
        }
    }

    pub fn push_front(&mut self, data: T) {
        let mut new_node = Box::new(Node::new(data));

        if let Some(old_head) = self.head.take() {

            new_node.next = Some(old_head);
            self.head = Some(new_node);
        } else {
            self.head = Some(new_node.clone());
            self.tail = Some(new_node);
        }
        self.len += 1;
    }

    pub fn push_back(&mut self, data: T) {

        let new_node = Box::new(Node::new(data));

        if let Some(mut tail) = self.tail.take() {
            tail.next = Some(new_node.clone());
            self.tail = Some(new_node);
        } else {
            self.head = Some(new_node.clone());
            self.tail = Some(new_node);
        }

        self.len += 1;
    }

    pub fn pop_front(&mut self) -> Option<T> {
        self.head.take().map(|old_head| {
            if let Some(next) = old_head.next {
                self.head = Some(next);
            } else {
                self.tail.take();
            }
            self.len -= 1;
            old_head.val
        })
    }

    pub fn pop_back(&mut self) -> Option<T> {

        if self.head.is_none() {
            return None;
        }
        if self.len == 1 {
            return self.pop_front();
        }

        let mut current = self.head.as_mut();

        while let Some(node) = current {

             if node.next.as_ref().map_or(false, |next| next.next.is_none()) {
                let last_node = node.next.take().unwrap();
                self.tail = Some(node.clone());
                self.len -= 1;
                return Some(last_node.val);
             }
             current = node.next.as_mut().map(|next| &mut **next); //the problem !!!!
        }
        None 
    }
    
}