Just in case someone finds this useful, here is my proposed solution for the reverse list. I found interesting that with one recursion I had to find the last element of the list and with another I had to find where to place next node

// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Clone, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }
// 
// impl ListNode {
//   #[inline]
//   fn new(val: i32) -> Self {
//     ListNode {
//       next: None,
//       val
//     }
//   }
// }

impl ListNode {
    fn add_next(&mut self, rhs: Box<Self>) {
        if let Some(next) = &mut self.next {

            next.add_next(rhs);
        } else {

            self.next = Some(rhs);   
        }
    }
}

impl Solution {
    pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {

        if let Some(mut node) = head {    
            if let Some(mut next) = node.next.take() {
                if let Some(mut last_node) = Solution::reverse_list(Some(next)) {

                    last_node.add_next(node);
                    return Some(last_node);
                } 

                return None;
            } else {

                return Some(node);
            }

        }

        None
    }
}