I for one don't have a problem with your tone.

> Realistically there is little benefit of having more than ~5 (one for
> fast standalone, one for scripting, a couple for targeting various
> environments like JVM or CLR etc)

Different 5 for everybody. Yes, some implementations have almost the
same niche. But there are surprisingly many niches.

> The fracturing of users / libraries,
> the duplication of work across different implementations is immensely
> saddening to me. I don't know what the ideal solution should be.

Merging existing implementations is something even I wouldn't attempt to
persuade their authors to do. Though in some cases users would benefit.

If I were forced to attempt this, I would start by trying to persuade
authors to share individual subsystems (e.g. GC, FFI, some libraries).

I don't think we have any SRFIs specifying how the internals of a Scheme
implementation should look, but the concept would make sense.
Standardized internal interfaces would make it easier to navigate the
codebase of an unfamiliar implementation, and would build bridges toward
eventually sharing the implementations of some of those interfaces. I
wouldn't expect any implementer to have time for this, but some loyal
users might.

I won't do any of the above; just throwing the sketch out there.

> My
> tentative hope is that a cohesive set of SRFIs grouped under a label of
> R7RS-large would eventually establish a strong core of scheme
> implementations and more or less cull the rest. With this mindset I
> don't think it is necessary for the SRFI process to be
> "Scheme-community-wide", because the scheme community would adapt to the
> designed pieces after the fact.

Despite the brashness of my approach to Scheme, I always try to serve
everybody - try to create a world where every current player has a
place, even if that player doesn't share my design sensibilities. People
with the attitude you describe are trying to serve themselves - create a
world where those with inconvenient opinions are cast aside. The problem
with that is, everyone has a different view of who's inconvenient.
You're unlikely to achieve unity that way.

At any given time, "the rest" of the implementations "cull" themselves.
Some implementers are bound to be more driven and/or lucky than others,
making those implementations have the most users or development effort.

Which implementations constitute "the rest"? Now, that changes over
time. Open source projects can always be resurrected.

A strong core is unlikely to come from a process that so far doesn't
include Bigloo, Chez, Chicken, Gambit, Guile, Kawa, Loko, MIT Scheme.
Perhaps it will include them in the future, but you've got your work cut
out for you.