Mutable borrow inside loop

I have a vector of tuples, each containing two strings. I want to transfer (one of) the two strings as a mutable reference into a hashmap. The other string is also transferred, but does not have to be mutable. The background is that I want to overwrite one string with the value of the other one later.

Given the following code:

use std::collections::HashMap;

fn main() {
    let mut foo = String::from("foo");
    let mut bar = String::from("bar");
    let mut v = vec![(foo, &mut bar)];
    let mut counter: HashMap<&str, (&str, &mut String, u8)> = HashMap::new();
    
    create_counter(&mut v, &mut counter);
}

fn create_counter<'a>(
    rows: &'a mut Vec<(String, &'a mut String)>,
    counter: &mut HashMap<&'a str, (&'a str, &'a mut String, u8)>,
) {
    let mut skip_count = 0;
    let len = rows.len();
    for i in 0..len {
        if i == len - 1 {
            break;
        }
        if skip_count > 0 {
            skip_count -= 1;
            continue;
        }

        let r = rows[i..i + 3].as_mut();

        if r[0].0 == r[1].0 && r[0].1 != r[1].1 {
            if r.len() == 2 || r[0].0 != r[2].0 {
                counter.entry(&r[0].0).or_insert((r[1].1, &mut r[0].1, 0)).2 += 1;
                skip_count = 1;
            } else {
                skip_count = 2;
            }
        }
    }
}

Unfortunately the borrow checker does not allow this and gives me two error messages:

cannot borrow `*rows` as mutable more than once at a time

cannot borrow `r[_].1` as mutable because it is also borrowed as immutable

I understand the problem, but unfortunately I have no idea how best to solve it.

Can someone please help me to solve these two problems?

Playground Link