Как можно преобразовать вектор объектов в структуру дерева данных?

Для преобразования вектора объектов в структуру дерева данных в Rust, можно использовать следующий подход:

1. Определить структуру для узла дерева, которая будет содержать данные и вектор указателей на дочерние узлы:

```rust
use std::rc::Rc;
use std::cell::RefCell;

struct Node {
    data: i32,
    children: Vec<Rc<RefCell<Node>>>,
    leaf: bool,
}
```

2. Создать функцию, которая будет рекурсивно добавлять дочерние узлы к каждой ноде:

```rust
fn add_child(root: Rc<RefCell<Node>>, child_data: i32, leaf: bool) -> Rc<RefCell<Node>> {
    let child = Rc::new(RefCell::new(Node {
        data: child_data,
        children: vec![],
        leaf: leaf,
    }));
    root.borrow_mut().children.push(Rc::clone(&child));
    child
}
```

3. Создать корневой узел и добавить дочерние узлы:

```rust
fn main() {
    let root = Rc::new(RefCell::new(Node {
        data: 1,
        children: vec![],
        leaf: false,
    }));

    let child1 = add_child(Rc::clone(&root), 2, false);
    let child2 = add_child(Rc::clone(&root), 3, true);

    // Добавление дочерних узлов к child1
    let child3 = add_child(Rc::clone(&child1), 4, true);
    let child4 = add_child(Rc::clone(&child1), 5, false);
}
```

4. При использовании типа Rc для управления памятью, необходимо учитывать, что Rc позволяет разделять неизменяемые ссылки на объекты между несколькими владельцами. RefCell используется для обеспечения внутренней изменяемости объекта в Rust.

5. Для учета атрибута leaf при создании нод, просто добавьте соответствующее поле в структуру Node и установите его значение в зависимости от необходимости.

Таким образом, вы можете преобразовать вектор объектов в структуру дерева данных, используя тип Rc для управления памятью и RefCell для обеспечения внутренней изменяемости объектов в Rust.

Главная проблема тут - лайфтаймы. В частности у переменной на стеке никогда не будет лайфтайма 'static . 
 Ну и отдавать в куда либо долгоживущее ссылку на временное значение - UB. Благо лайфтаймы и тут спасают. 
 Собственно для этого Rc и нужен - он владеющая ссылка. Соответственно в нём должно быть значение, а не ссылка (ссылка на ссылку редко когда нужна). 
 
 
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Default, Clone, Debug)]
struct NodeInner {
    name: String,
    source: String,

    path: String,
    leaf: bool,
    children: Vec<Node>,
}

#[derive(Default, Clone, Debug)]
struct Node(Rc<RefCell<NodeInner>>);

impl Node {
    fn fast(name: impl Into<String>, source: impl Into<String>) -> Self {
        Self(Rc::new(RefCell::new(NodeInner {
            name: name.into(),
            source: source.into(),

            path: String::new(),
            leaf: true,
            children: Vec::new(),
        })))
    }

    fn insert(&self, node: Node) {
        let mut current = self.clone();
        for part in node.0.borrow().source.split(".") {
            let inner = node.0.borrow();
            let found = inner.children.iter().find(|&v| v.0.borrow().path == part);

            match found {
                None => {
                    let tmp = Node::fast(String::new(), String::new());
                    current.0.borrow_mut().children.push(tmp.clone());
                    current = tmp;
                }
                Some(val) => current = val.clone(),
            }
        }
    }
}

fn main() {
    let mut root = Node::default();
    root.insert(Node::fast("First", "e"));
    root.insert(Node::fast("First", "e.sources"));
    root.insert(Node::fast("First", "e.sources.two"));
    root.insert(Node::fast("First", "e.secret"));
    root.insert(Node::fast("First", "e.secret.left"));
    root.insert(Node::fast("First", "e.secret.right"));
    print!("{:#?}", root);
}
 
 Как заполнять поля уже сами разбирайтесь, думаю тут не сложно