{} gets the byte the pointer points to.  0->{L1}:Disp {L1}>Dec. 0 would be displayed.
1. yes.
2. depends on your order of operations.
3. i think so, yes.
4. i think so, yes

1. yes, but its not the same size as {L1+12}
2. depends on order of operations, the example in one would do this: {((L1+Z)*4)+12}, the second one would do {((Z*4)+L1)+12}
3. yes
4. yes

also, {L1+1} is the exact same size as A, as in, these two examples will be the exact same size when compiled
{L1+1}+2->{L1+1}
A+2->A

that's not what we mean by size, we mean size when compiled.  umm... not sure how to explain it...

like the larger the size, the larger the executable is

2. depends on order of operations, the example in one would do this: {((L1+Z)*4)+12}, the second one would do

Order of operations ... forgot about that ... again That's why my program didn't work ... it has nothing to do with nested braces....

Thanks!

It sounds like you have the right idea.  Since L1-L6 are just numbers, it makes sense for the compiler to add/subtract/multiply/divide etc. to create a single number BEFORE parsing so that the program doesn't have to do it during runtime.  However, if you have any variables or non-constants then the compiler can not make this optimization and the size will increase.

Your 2 examples {L1+Z*4+12} and {Z*4+L1+12} would return different values as some people have said due to strict left-to-right order of operations.  However, I assume you are asking about the difference between {L1+(Z*4)+12} and {Z*4+L1+12} and in that case, YES, the second one is more optimized since L1 and 12 are combined to form a single number that will get added to the variable part.

You can use as many braces inside of braces as the stack can handle and yes, they act like parenthesis when you use them that way.  You can read from expressions with nested braces and store to them.  But of course, the less parenthesis you need, the more optimized it is.  If its possible try to put all that stuff at the front. {{L1+12}+L1+24} is more optimized than {L1+{L1+12}+24} for the reason above in addition to the fewer acting "parenthesis".

Yup. It can be rather useful for some complicated RPGs. In TI-BASIC, I often did stuff like L3(A+L3(Z)), for example. If I remember, ROL2 required a lot of those

Keep in mind it can eventually make your code hard to read, though, especially if you decide to put a project on hold for a while.

That's what comments are for  You should see Runer's Sprite Editor source, more than half of the size of the program was indents and comments.  That's another paradigm that BASIC programmers are too used to, commenting in the code doesn't affect the final executable at all since they are all ignored when compiling.  In BASIC however, its seen as wasteful since it becomes part of the program.