I have supplied some examples of Type Assertions below that will hopefully shine some light on this feature for you.

The interesting bit is that if a set of parentheses has an affect on the scope of a type assertion, the parentheses are removed by type erasure during compilation. This means that example b below results in (x) in the JavaScript, whereas example c results in simply x.

The only reason to use parentheses to set the scope of the type assertion is when you want to apply to a part of the right-hand expression, in which case you would place the type assertion inside of the parentheses, as shown in example e.

interface SomeType {
    name: string;
    id: number;
}

var x = {};

var a: SomeType = <SomeType> x;

// Note, when brackets do not affect 
// type assertions they will be left in the output
var b: SomeType = <SomeType> (x);

// When brackets affect type assertions,
// they are erased along with the type information
var c: SomeType = (<SomeType> x);

// Two errors:
// - SomeType is not assignable to d
// - Property id does not exist on x
var d: number = <SomeType> x.id;

// Brackets are useful here:
var e: number = (<SomeType> x).id;

// More complex example
var func = () => {
    return x; // return type is {}
};
var f: SomeType = <SomeType> func();

What the operator precedence of && of || means is that this:

let z = 5 || (x = false) && (y = true);

gets evaluated as:

let z = 5 || ((x = false) && (y = true));

and not as

let z = (5 || (x = false)) && (y = true);

It's not something that indicates when the values on each side of an operator is evaluated. That's done by the mechanics of each individual operator. For example, for ||, it's specified here:

1. Let lref be the result of evaluating LogicalANDExpression.
2. Let lval be ? GetValue(lref).
3. Let lbool be ToBoolean(lval).
4. If lbool is false, return lval.
5. Let rref be the result of evaluating BitwiseORExpression.
6. Return ? GetValue(rref).

It evaluates GetValue(lref) before GetValue(rref) runs.

In other words, operator precedence indicates which tokens are applied to which operator, and in what order, but not how/when a given operator evaluates the values on its left and right side.