Removes ParenthesizedExpr from the current version of java-grammar. It's replaced by an attribute of ASTExpression, that stores the number of parentheses levels around the expression. Most rules, and all analysis passes, would never care about parentheses. So having an extra node causes the following problems:

• if the parens are unnecessary, then semantically equivalent expressions are parsed differently, which introduces corner cases the rules should potentially deal with...
• if the parens are necessary, then they can be inferred by the context (precedence of the operators outside and inside the parens), and in that sense are redundant

So eg as today, 1+2*3 is parsed

+ AdditiveExpr
   + `1`
   + MultiplicativeExpr
      + `2`
      + `3` 

but now, this is the same as 1+(2*3) (except in the latter the multiplicative expression has @Parenthesized set to true).

OTOH (1+2)*3 is parsed as

+ MultiplicativeExpression
   + AdditiveExpr [ @Parenthesized = true() ]
      + `1`
      + `2`
   + `3` 

Notice, that this really is a simplification, since because of operator precedence rules, the only way you can nest an addition into a multiplication is with parentheses anyway. That means, that the ParenthesizedExpr in this context was entirely redundant.

Finally, 1 + 2 + 3 is parsed as

+ AdditiveExpr
  + `1`
  + `2`
  + `3` 

whereas (1+2)+3 is parsed as

+ AdditiveExpr
  + AdditiveExpr [ @Parenthesized = true() ]
     + `1`
     + `2`
  + `3` 

meaning, we have to preserve the parens on a node that would otherwise have been flattened - even though they're unnecessary... But that's in fact consistent with 1+(2+3), which already is not flattened either:

+ AdditiveExpr
  + `1` 
  + AdditiveExpr [ @Parenthesized = true() ]
     + `2`
     + `3`