Simplify inline comments in parentheses handling logic

Reduced verbose comments to concise labels. Details are already covered by
the function name is_non_commutative_or_comparison() and inline comments
on Add/Mul operators.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: steffen-heil-secforge

src/generation/generate.rs

@@ -3082,9 +3082,7 @@ fn should_skip_paren_expr<'a>(node: &'a ParenExpr<'a>, context: &Context<'a>) ->
     // Keep parens on left side of assignment if:
     // - Contains type assertion: (obj.prop as Type) = value is valid, but obj.prop as Type = value is not
     // - Ends with !: (x!) = y avoids ambiguity with !=
-    if assign_expr.left.range().contains(&node.range())
-      && (is_type_assertion(node.expr.kind()) || expr_ends_with_non_null_assertion(&node.expr))
-    {
+    if assign_expr.left.range().contains(&node.range()) && (is_type_assertion(node.expr.kind()) || expr_ends_with_non_null_assertion(&node.expr)) {
       return false;
     }
   }
@@ -3124,7 +3122,6 @@ fn should_skip_paren_expr<'a>(node: &'a ParenExpr<'a>, context: &Context<'a>) ->
     }
   }
 
-
   // In non-PreferNone modes, we've handled all cases where parens should be removed
   if context.config.use_parentheses != UseParentheses::PreferNone {
     return false;
@@ -3218,21 +3215,16 @@ fn should_skip_paren_expr<'a>(node: &'a ParenExpr<'a>, context: &Context<'a>) ->
         }
 
         if parent_bin.right.range().contains(&node.range()) {
-          // Same operator - parens matter on right side for non-commutative ops
-          // Also for comparison/equality ops: a === b === c is (a === b) === c, different from a === (b === c)
-          // Addition: not associative due to type coercion: "x" + (4 + 2) = "x6" vs "x" + 4 + 2 = "x42"
-          // Multiplication: not associative due to floating-point precision
+          // RIGHT SIDE: Keep parens for left-associative operators
           if is_non_commutative_or_comparison(&parent_bin.op()) {
             return false;
           }
         } else {
-          // LEFT SIDE
+          // LEFT SIDE: Exponentiation is right-associative
           if matches!(parent_bin.op(), BinaryOp::Exp) {
-            // Exponentiation is right-associative, so left side needs parens: (a ** b) ** c
             return false;
           }
-          // For left-associative operators, left side parens are redundant: (a + b) + c === a + b + c
-          // Allow removal by returning true (skip parens)
+          // LEFT SIDE: Remove redundant parens for left-associative operators
           if is_non_commutative_or_comparison(&parent_bin.op()) {
             return true;
           }
@@ -3305,7 +3297,6 @@ fn should_skip_paren_expr<'a>(node: &'a ParenExpr<'a>, context: &Context<'a>) ->
     }
   }
 
-  // Keep parens for assignment expressions with member access, call, or new: (a = b).prop or (a = b)() or new (a = b)()
   // Member access, call, and new have higher precedence than assignment, so parens are needed
   if matches!(node.expr, Expr::Assign(_))
     && matches!(