Lambda the Ultimate

Just use ligatures, it isn't hard, and the mapping from keyboard input to character is extremely direct.

Color coding is also a good idea, somewhat orthogonal to varying the characters filling a role. I don't actually have much to say here, except redundant expansion, repeating points differently. I could use tiny dialogs like this one as motivation:

Stu: You plan to support Unicode, of course.
Wil: No way in hell.
Ned: Unpopular attitude.
Stu: What a jerk! I'm not following you any more.
Wil: And how would I notice that?

Suppose several languages I want to use together work fine in ascii: I could ignore utf8 and shrug insolently in response to complaints. Or if I think of an excuse to want more characters, I have incentive to permit more than one way to encode characters, with trivial extra cost — perhaps none when only ascii appears. If an octet has high bit set, I can parse a utf8 charater, or if I see an ampersand, I can see if this is followed directly by a char entity then a trailing semicolon. (I don't use existing tools to parse.) Then folks can put whatever they want in string constants; further, a lot of browser text markup becomes valid code input when pasted directly into a code editor.

When syntax is Lisp, I'd like more delimitors, so scratching that itch is an excuse to deal correctly with utf8 and to accept char entities too. A large increase in usable operators would be nice as well. Coloring at presentation time would also improve code legibility. But I spend a fair amount of time cutting and pasting code in different places, but most destinations I use won't syntax color and it's a waste of time to do it by hand. (Typically I go grayscale in email, darkening important things and lightening trivial detail like comments.) More structure hinting seems better. I like working with ASTs, and a tree of pairs is fine, but showing different kinds of lists using different delimitors would improve readability for me. I can just as easily ignore the difference between delimitors and see them all as parens (or quotes in the case of strings).

The glyph-mapping that you are describing could be somewhat fragile: it does not checked anywhere, so it is up to the user to keep it in sync with the meaning of the code.

That's why I mentioned checking they were true in code analysis. For example, suppose the use of one open delimitor implies a special form is inside. Not only must the matching close delimitor appear as expected, you also generate a warning if it's not a special form.

In some cases, a delimitor might alter the grammar, say to begin and end Smalltalk syntax, or to enable operator precedence or infix notation. But to avoid making everyone learn everything, a tool could rewrite a bit of code to standardize on exactly one way of doing it, thus eliminating variants you don't care to know about. I'm in favor of viewing all the meaningful nuances as AST differences, with syntax meaning nothing itself, except in so far as you get a different AST after a change.

I suppose two devs, Jim and Ivy, won't like each others choices of delimitors, so remapping them would be nice. And some folks like sparing effects, while others like baroque density of annotation. Dialing code into your comfort zone seems better than being repulsed at someone else's style. Hypothetically, when studying a particular issue, it might be nice to dial down everything except one semantic angle you want emphasized. It seems easy enough to have a terse notation to declare what characters mean locally when they get remapped from standard notation.

opens the door to homoglyph attacks as exemplified by things like mimic

I'm inclined to allow declarations that limit or forbid where things can appear in code. For example, you might forbid definitions of methods specialized on a type outside a particular scope like this file here. Being overly restrictive at first seems a good idea (outlaw everything). When reasoning about how code behaves, it helps to know certain interesting cases are forbidden, so you need not look for them. A histogram view of all non-ascii codepoints used would help provide oversight.

Exceptions to a general rule can be white or blacklisted. One might outlaw all non-ascii codepoints in static code other than an explicitly whitelisted set. One might also require some codepoints appear only as character entities with unambiguous names. (Might have to declare those entities.)

There's plenty of things I don't like about Unicode. But inflexibly forbidding things would encourage work-arounds increasing complexity.