Fork away, it is open source after all.

And it will most definitely break stuff since removing the $ would clash with any defined constants.

It will not break stuff if defined constants will have higher priority. In such case developer can just leave $ prefix.

It would be really great if PHP developers have an option to choose whether to use the prefix or not. Eventually all new code will be written without $ and there will be no conflicts.

There are also edge cases like 

$a['foo'] = 1;
$foo = 2;
echo $a[foo];

That would behave differently with optional $'s

And I like the obvious separation between constants and variables. It avoids side-effects if someone somewhere suddenly creates a constant that then goes and changes behaviour all over the place because of this constants-over-variables approach.

It is a matter of programmer's personal attentiveness. In your example there is a mix of using $ and not using it. Most developers will not do it. Besides in other languages this theoretical problem is even not discussed. For example, as you know in C/C++ there is a de facto standard of using CAPITAL LETTERS for constants which is enough to distinguish them from variables. Many PHP developers follow this concept.

From the other side if one wanted to calculate how many key strokes will it save to allow not to use $ prefix in a PHP project with 100000 lines of code - this number would be huge. No one will argue that PHP is derived from C. It is evident that C language itself was created to minimize typing (as one of its primary goals, comparing to academic Pascal is enough to see this). So why not to follow the original path - to avoid unneeded typing while leaving a possibility to use $ for compatibility and in some special cases?

The same arguments can be applied to { } arrays and "in" operator.

Minimizing keystrokes never has and never will be a priority.

It is just one of arguments, another one is that it will improve code readability. While it is not so evident in simple examples: who cares what to write

  $foo = $bar

or

  foo = bar

and all of these seems to be clear and readable. But consider more complicated code:

  while (TRUE) {
    $k = strpos( $sql, $quoteChar, $j );
    $escaped = false;
    if ($k === false) {
      break;
    }
    $l = $k - 1;
    while ($l >= 0 && $sql{$l} == '\\') {
      $l--;
      $escaped = !$escaped;
    }
    if ($escaped) {
      $j = $k + 1;
      continue;
    }
    break;
  } 

Isn't it more readable without $:

  while (TRUE) {
    k = strpos( sql, quoteChar, j );
    escaped = false;
    if (k === false) {
      break;
    }
    l = k - 1;
    while (l >= 0 && sql{l} == '\\') {
      l--;
      escaped = !escaped;
    }
    if (escaped) {
      j = k + 1;
      continue;
    }
    break;
  } 

?