I'm busily killing off all the stray SET-PATH! and GET-PATH! that exist... (because CHAIN! is going to be underneath PATH!, you won't be able to put a path in a chain such that you would describe the path as being set or gotten... the colon can't be "applied to" the path).
I came across the pleasing SIGIL! test:
for-each [sigil items] [
~null~ [ word tu.p.le pa/th [bl o ck] (gr o up) {fe n ce} ]
:: [ word: tu.p.le: pa/th: [bl o ck]: (gr o up): {fe n ce}: ]
: [ :word :tu.p.le :pa/th :[bl o ck] :(gr o up) :{fe n ce} ]
^ [ ^word ^tu.p.le ^pa/th ^[bl o ck] ^(gr o up) ^{fe n ce} ]
& [ &word &tu.p.le &pa/th &[bl o ck] &(gr o up) &{fe n ce} ]
@ [ @word @tu.p.le @pa/th @[bl o ck] @(gr o up) @{fe n ce} ]
$ [ $word $tu.p.le $pa/th $[bl o ck] $(gr o up) ${fe n ce} ]
][
for-each 'item items [
assert [bindable? item]
if (degrade sigil) <> sigil of item [
fail [mold item]
]
]
]
: and :: are not going to be SIGIL! at all soon. But as a first step, I need to get rid of SET-PATH! and GET-PATH!
Behold Just A Little Nice Rebolish Moment
I realized I needed to kill QUASI-TUPLE! and QUASI-PATH! also...
for-each [sigil items] [
~null~ [ word tu.p.le pa/th [bl o ck] (gr o up) {fe n ce} ]
:: [ word: tu.p.le: _ [bl o ck]: (gr o up): {fe n ce}: ]
: [ :word :tu.p.le _ :[bl o ck] :(gr o up) :{fe n ce} ]
^ [ ^word ^tu.p.le ^pa/th ^[bl o ck] ^(gr o up) ^{fe n ce} ]
& [ &word &tu.p.le &pa/th &[bl o ck] &(gr o up) &{fe n ce} ]
@ [ @word @tu.p.le @pa/th @[bl o ck] @(gr o up) @{fe n ce} ]
$ [ $word $tu.p.le $pa/th $[bl o ck] $(gr o up) ${fe n ce} ]
][
for-each 'item items [
if blank? item [continue]
assert [bindable? item]
if (degrade sigil) <> sigil of item [
fail [mold item]
]
]
]
When you have the parts, you just use them... and I picked a blank.
Of course I could have used other things.
:: [ word: tu.p.le: ~ [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: - [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: # [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: !!! [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: <dead> [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: ~null~ [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: ~dead~ [bl o ck]: (gr o up): {fe n ce}: ]
:: [ word: tu.p.le: #dead [bl o ck]: (gr o up): {fe n ce}: ]
In a lot of cases, trash (~) would be the right choice for a "this is invalid slot". But I feel it doesn't work quite as well in this context.
~null~ [ word tu.p.le pa/th [bl o ck] (gr o up) {fe n ce} ]
:: [ word: tu.p.le: ~ [bl o ck]: (gr o up): {fe n ce}: ]
: [ :word :tu.p.le ~ :[bl o ck] :(gr o up) :{fe n ce} ]
^ [ ^word ^tu.p.le ^pa/th ^[bl o ck] ^(gr o up) ^{fe n ce} ]
Visually the best choice may be a hyphen, because it divides the space above and below evenly:
~null~ [ word tu.p.le pa/th [bl o ck] (gr o up) {fe n ce} ]
:: [ word: tu.p.le: - [bl o ck]: (gr o up): {fe n ce}: ]
: [ :word :tu.p.le - :[bl o ck] :(gr o up) :{fe n ce} ]
^ [ ^word ^tu.p.le ^pa/th ^[bl o ck] ^(gr o up) ^{fe n ce} ]
But BLANK! has properties of being weird and unevaluative that probably give it the edge, while looking about the same. But I'm on the fence, maybe - is good. 
Note That :pa/th and pa/th: Will Become LOADable Again...
You just won't ask about colons applied on the head or tail of the paths, because you'll have to "dig" to find the chains underneath.