Rust iterator with muatble reference keeps blocking other references after being used

Question

I am giving a mutable reference of a Vec to an Iterator, so it can add Elements to it while just keeping an index of the Element. Thus after the Iterator being "used" shouldn't then the Vec be able to be referenced again?

(Here a link to a Rust playground example)

struct MyElement{
    category_index: usize,
    ...
}

impl MyElement{
    fn iter_from_src<'a>(source: &'a str, categories: &'a mut Vec<&'a str>)
      -> impl Iterator< Item = MyElement > {
        ...
        std::iter::from_fn(move || -> Option<MyElement> {
            ... //some iterator logic
            let category = find_category_in_source(source);
            if let Some(index) = categories.iter().position(|c| *c == category) {
                //no reference of categories is given to MyElement exept of the index
                Some( MyElement{ category_index: index, ... } )
            } else {
                let index = categories.len();
                // the only mutable usage of categories
                categories.push(category);

                Some( MyElement{ category_index: index, ... } )
            }

        })
    }
}

fn main() {
    let source: String = get_source();
    let mut categories = Vec::with_capacity(32);
    let mut elements = Vec::with_capacity(1024);
    
    for element in MyElement::iter_from_src(&source, &mut categories) {
        elements.push(element);
    }

    ...
    // error occurs here
    println!("{categories:#?}");

}

and there is no difference in using

let elements = MyElement::iter_from_src(&source, &mut categories).collect();

instead of the for-loop.

Eitherway the compiler Refuses:

error[E0502]: cannot borrow `categories` as immutable because it is also borrowed as mutable
  --> src/main.rs:81:16
   |
74 |     for element in MyElement::iter_from_src(&source, &mut categories) {
   |                                                      --------------- mutable borrow occurs here
...
81 |     println!("{categories:#?}");
   |                ^^^^^^^^^^
   |                |
   |                immutable borrow occurs here
   |                mutable borrow later used here

I am pretty new to rust so it can just be me understanding a concept wrong.

Still: Why does this throw an error?

And how can it be made possible, that the categories can not be referenced while the Iterator exists though they can afterwards?