Rust multiple lifetimes in structs

I have problems with understanding the behavior and availability of structs with multiple lifetime parameters. Consider the following:

struct  My<'a,'b> {
    first: &'a String,
    second: &'b String
}

fn main() {
    let my;
    let first = "first".to_string();
    {
        let second = "second".to_string();
        my = My{
            first: &first,
            second: &second
        }
    }
    println!("{}", my.first)
}

The error message says that

   |
13 |             second: &second
   |                     ^^^^^^^ borrowed value does not live long enough
14 |         }
15 |     }
   |     - `second` dropped here while still borrowed
16 |     println!("{}", my.first)
   |                    -------- borrow later used here

First, I do not access the .second element of the struct. So, I do not see the problem.

Second, the struct has two life time parameters. I assume that compiler tracks the fields of struct seperately. For example the following compiles fine:

struct  Own {
    first:  String,
    second: String
}

fn main() {
    let my;
    let first = "first".to_string();
    {
        let second = "second".to_string();
        my = Own{
            first: first,
            second: second
        }
    }
    std::mem::drop(my.second);
    println!("{}", my.first)
}

Which means that even though, .second of the struct is dropped that does not invalidate the whole struct. I can still access the non-dropped elements.

Why doesn't the same the same work for structs with references?

The struct has two independent lifetime parameters. Just like a struct with two type parameters are independent of each other, I would expect that these two lifetimes are independent as well. But the error message suggest that in the case of lifetimes these are not independent. The resultant struct does not have two lifetime parameters but only one that is the smaller of the two.

If the validity of struct containing two references limited to the lifetime of reference with the smallest lifetime, then my question is what is the difference between

struct My1<'a,'b>{
 f: &'a X,
 s: &'b Y,
}

and

struct My2<'a>{
 f: &'a X,
 s: &'a Y
}

I would expect that structs with multiple lifetime parameters to behave similar to functions with multiple lifetime parameters. Consider these two functions

fn fun_single<'a>(x:&'a str, y: &'a str) -> &'a str {
    if x.len() <= y.len() {&x[0..1]} else {&y[0..1]}
}

fn fun_double<'a,'b>(x: &'a str, y:&'b str) -> &'a str {
    &x[0..1]
}

fn main() {
    let first = "first".to_string();
    let second = "second".to_string();
    
    let ref_first = &first;
    let ref_second = &second;
    
    let result_ref = fun_single(ref_first, ref_second);
    
    std::mem::drop(second);
    
    println!("{result_ref}")
}

In this version we get the result from a function with single life time parameter. Compiler thinks that two function parameters are related so it picks the smallest lifetime for the reference we return from the function. So it does not compile this version.

But if we just replace the line

let result_ref = fun_single(ref_first, ref_second);

with

let result_ref = fun_double(ref_first, ref_second);

the compiler sees that two lifetimes are independent so even when you drop second result_ref is still valid, the lifetime of the return reference is not the smallest but independent from second parameter and it compiles.

I would expect that structs with multiple lifetimes and functions with multiple lifetimes to behave similarly. But they don't.

What am I missing here?