Imagine I decide to use $1 and $2 etc. to be some kind of positional substitution notation in a dialect:
>> substitute [a b $2 c d $1 e f] [<some> <thing>]
== [a b <thing> c d <some> e f]
If I reflect it out to the user in any way, it will carry the decoration I don't want unless I get involved in removing the extra digits:
>> substitute/trace [a b $2 c d $1 e f] [<some> <thing>]
DEBUG: $1.00 is <some>
DEBUG: $2.00 is <thing>
== [a b <thing> c d <some> e f]
Being a headache in that way--and having to decide things like if you round down $1.01 or error--means it's not a fit for such purposes. It wasn't intended to be used that way, but my point was just that it's one of my pet peeves about the type, because I would use DOLLAR-INTEGER! more than MONEY! in the kinds of things I'd use Rebol stuff for.
Where do you find the time for all these interests? 
Point was just whatever it is that is innate in us to let us see structure in streams of words, we want to leverage that "zone" as I called it. Most languages don't try to go there.
Rebol does so on purpose, letting you organically decide when you want to delimit e.g. with BLOCK! in parse rules ([try some integer!] vs. [try [some integer!]]) or GROUP! in evaluator code. As you get more comfortable with things, the training wheels fall off and you tend to delimit less...or at least much more purposefully. As with English.
One place I see THE-BLOCK! coming into great use is if for a dialect that is not purely mechanical (the way PICK and FOR-EACH are), and leaving the @ off of a block signaling that you would like the "INSIDE / IN" binding to be applied automatically.
e.g. some variation of the CIRCLED dialect might work like so:
>> x: 10 y: 20
>> var: circled [x (y)]
== y
>> get var
== 20
>> var: circled @[x (y)]
== y
>> get var
** Error: y is not bound
Being able to draw that distinction is dependent on the callee being able to see the sigil. And I think that if we say that @[...] blocks do not bind (as no other @ types do, at least by default) you help to guide the implementation offerings of the dialects in this direction. If you don't have a binding passed in, you can't give one back (unless the value already had it deliberately glued on)
I've mentioned the other cues here that are useful, such as when ANY and ALL don't want to evaluate but only to run the predicate:
>> any/predicate [3 + 4 10 + 20] :even?
== 30
>> any/predicate @[3 + 4 10 + 20] :even?
== 4
This is important if someone else ran a reduce step and you still have questions about the data... it keeps you from having to do something like MAP-EACH item to a QUOTED! version just to suppress evaluation in the ALL. It could be done with a refinement, but the single-character notation as a convention--which aligns with not adding binding--seems a salient solution.
So it's far from useless in my eyes. And I will reiterate that an important application of TYPE-TUPLE! is when you have a predicate function inside an object or module:
>> obj: make object! [lucky?: number -> [number = 7]]
>> parse [7 7 7] [some &obj.lucky?]
== 7
And then TYPE-PATH! when your function has refinements.