How about:

  x = .nesting {
    color: hotpink;
  }

  y = x > .is {
    color: rebeccapurple;
  }

  y > .awesome {
    color: deeppink;
  }

plus:

  x = .nesting;
  y = x > .is;
  z = y > .awesome;

  x {
    color: hotpink;
  }

  y {
    color: rebeccapurple;
  }

  z {
    color: deeppink;
  }

The names x, y and z aren't ambiguous because they are lexically defined. They could be allowed to shadow tags:

  pre = .foo > .bar;

then from that point on, pre isn't the HTML tag, but the above definition. Or else tags could be reserved: cannot use those as names. (Causing trouble when new tags get introduced; bad idea.)

Regarding the @nest syntax, why couldn't it look like an attribute?

  ...sel... {
     color: blue;
     nest: > .whatever { ... }
  }

Or just the colon:

  ...sel... {
     color: blue;
     : > .whatever { ... }
  }

Why use containment to express the nesting? What is being nested is the selectors. The braces group something else: the attributes affected by selectors. Why would nested selectors have to go into those braces?

The + character at the start of a rule could mean "the selector of the previous rule":

  .nesting { color: hotpink }
  + > .is { color: rebeccapurple }
  + > .awesome { color: deeppink }

Or use a master outer brace for this:

  {
      .nesting { color: hotpink }
      > .is { color: rebeccapurple }
      > .awesome { color: deeppink }
  }

The understanding is that the rules grouped in the brace have a cumulative selector, rather than independent selectors.

Or what if braces just group, and @nest (or whatever) is required to indicate the selector stacking semantics:

  @stack {
     .nesting { color: hotpink; }
     > .is { color: rebeccapurple; }
     > .awesome { color: deeppink; }
  }

Now you can have N levels of selector refinement without N levels of syntactic containment. The containment is still available:

  @stack {
     .nesting { color: hotpink; }
     > .is { color: rebeccapurple; }
     {  
       /* parallel rules: not a stack */
       .awesome { color: deeppink; }
       .terrific { color: yellow; }
     }
     @stack {
       /* stack-in-stack, cross-producting. */
       .even { color: red; }
       .more { color: green; }
       .nested { color: blue; }
     }
  }

Here, because the nested @stack follows a block of parallel rules, a Cartesian product semantics can come into effect. That is to say, it is equivalent to:

  @stack {
     .nesting { color: hotpink; }
     > .is { color: rebeccapurple; }
     {  
       @stack {
         .awesome { color: deeppink; }
         .even { color: red; }
         .more { color: green; }
         .nested { color: blue; }
       }
       @stack {
         .terrific { color: yellow; }
         .even { color: red; }
         .more { color: green; }
         .nested { color: blue; }
       }
     }
   }
 

The @stack following a parallel rule causes the @stack to distribute into the parallel branches.

Kind of like Bash brace expansion:

  $ echo nesting-is-{awesome,terrific}-even-more-nested
  nesting-is-awesome-even-more-nested nesting-is-terrific-even-more-nested