Why would rust error on accessing mutable borrow while immutable borrow isn't accessed anywhere?

Even though you don't access y, creating it is enough to invalidate any existing mutable borrows.

What NLL (non-lexical lifetimes) changed is only that a reference is considered alive until its last usage, and not until the end of the scope. But a reference is always considered alive for some time.

Presumably, the behavior you want was not implemented because it's not useful: there is little value in reference that is never used.

The problem isn't whether you're accessing y, the problem is that you're accessing v itself when you write &v. Note that your code works if you create y from z:

fn main() {
    let mut v = vec![];
    let z = &mut v;
    let y = &*z;
    z.push(1);
    println!("{:?}",z); //accessing mutable borrow
}

Playground

Note that this is evidenced in the error message for your original code:

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
 --> src/main.rs:4:13
  |
3 |     let z = &mut v;
  |             ------ mutable borrow occurs here
4 |     let y = &v;
  |             ^^ immutable borrow occurs here
5 |     z.push(1);
  |     --------- mutable borrow later used here

The error marks &v as problematic, not y.

2 rules:

1- Immutable and mutable reference to the same variable cannot exist at the same time

2- The lifetime of an immutable reference lasts till its last usage

The first code fails because the immutable and mutable should not CO-EXIST (however they co-exist which is against rust borrowing rules). The variable z is mutable and its scope is from line 3 (let z = &mut v;) till line 6 (println!("{:?}",z)
). During this duration, the immutable reference should not exist. However the immutable reference exists during this scope which is on line 4 which is let y = &v;.

fn main() {
    let mut v = vec![];
    let z = &mut v; // --------------------------------- its lifetime starts here 
    let y = &v;   // y's lifetime start and ends here   |                              
    z.push(1); //                                       | z lifetime ends here                                                  
    println!("{:?}",z); 
  }
  // as you see y and z coexists

In the second code which compiles, is due to the fact that immutable and mutable does not co-exist. The variable y is a reference with a scope which starts and ends at the line 3 (since we are not using variable y afterwards). The scope of a variable starts from the line on which it is first used and ends on the line on which it is last used.

fn main() {
    let mut v = vec![];
    let y = &v;  //      y's lifetime starts and ends here
    let z = &mut v; //   z's lifetime starts here
    z.push(1);
    println!("{:?}",z); // accessing immutable borrow
}
// as you see y and z does not coexist