More sketching:

- An implementation would start reading a file with its default
implementation-defined syntax (RnRS + maybe extensions and deviations).

- When it encounters the standard #!r6rs directive, or a proposed #!r7rs
directive, it sets its read syntax equivalent to that Scheme report with
no extensions (or causes an error if it doesn't support that syntax).

- When it encounters #!(srfi 234 [options...]) it modifies the current
read syntax by ensuring SRFI 234 is turned on. (If SRFI 234 does not
specify any syntax changes, this is an error. If it specifies other
things in addition to syntax, e.g. procedures or variables, those are
not imported or otherwise affected by the #!(srfi ...) directive, only
the syntax is. Any procedures must be imported separately with ordinary
import statements.) If SRFI 234 was already turned on but the options
given are different from the previous ones, the options are changed to
the new ones (i.e. the effect is the same as first turning off SRFI 234
syntax and then turning it on again with the new options).

- When the reader encounters #!(no-srfi 234) it ensures SRFI 234 changes
are turned off in the read syntax. Again, if SRFI 234 specifies other
things in addition to syntax, those are not affected (symbols are not
unimported, etc.)

I don't know whether it makes sense to keep adding new #!rNrs
identifiers after #!r6rs (#!r7rs, maybe #!r7rs-large, #!r8rs, etc.)
Would it be better to have something like #!(scheme 7) or #!(scheme 8)?
Also Racket has things like "#lang racket/base". A more general

     #!(lang whatever <options...>)

might make sense. If we go down this road we should take some time to
explore how different scenarios would play out. John and others had
already done some thinking mechanisms to support non-Scheme source
languages and translate to Scheme.

Finally, for context, here's the relevant part of R6RS: "An
implementation must not extend the lexical or datum syntax in any way,
with one exception: it need not treat the syntax #!⟨identifier⟩, for any
⟨identifier⟩ (see section 4.2.4) that is not r6rs, as a syntax
violation, and it may use specific #!-prefixed identifiers as flags
indicating that sub- sequent input contains extensions to the standard
lexical or datum syntax. The syntax #!r6rs may be used to signify that
the input afterward is written with the lexical syn- tax and datum
syntax described by this report. #!r6rs is otherwise treated as a
comment; see section 4.2.3."