This is a rather poor rant. There's pretty much an easy answer to everything he describes that's been done in the academic world, and in other programming languages for decades, and almost certainly in his own programming language for similar problems.

    Can I copy it into my own spec or would that be 
    copyright infringement? Can I write something myself  
    that means the same? Or do I have to link to the spec 
    and require my users to pay to read it? 

Giving a summary is allowed even in the most draconian of interpretations of copyright. More loosely, pulling a quote of a few lines is standard for any sort of academic exercise; essays on novels certainly don't have you pull out the novel when they want to quote a bit of text.

    What if your language doesn’t have exceptions? What 
    does it mean to provide a status flag? 

You certainly have places elsewhere in your language for handling errors. How do you handle integer divide by zero? How do you handle timeouts when doing networking? How do you handle disk full errors? I hope you don't go stomping along after an error in those cases.

    This may have made sense at the time of the original 
    spec in 1985 but it’s mutable global state – something 
    that has long been recognized as problematic and which 
    languages are increasingly moving away from.

This is because statelessness is a leaky abstraction. Your machine's saving to disk, it's allocating memory for other things, it's pulling in stuff and shooting stuff over the network. Floating point has lots of knobs that you need to turn because there are various rounding rules for various problem domains. You've almost certainly got a type system for your language, perhaps your answer is to create, or have a way to create, a floatRoundUp type for when a user needs to go beyond your default rules. In a pure functional definition, I think one way to consider the problem is to think of a floating point type as the actual number and the state registers. If you don't care, then just use the number part, if the state register matters, put those in too. Saving flags means that you can get repeatability. With a given set of flags, you'll always get the same answer.

    Program block? Attribute specification? Nothing else in 
    my language works this way. How do I even apply this in 
    practice? If attributes are lexically scoped then that 
    would mean rounding modes only apply to code textually 
    within the scope – if you call out to a function its 
    operations will be unaffected. If on the other hand 
    attributes are dynamically scoped then it works with 
    the functions you call – but dynamically scoped state 
    of this flavor is really uncommon these days, most 
    likely nothing else in your language behaves this way.

There are two ways of handling this problem. Decide for the user, or expose the functionality needed to provide scoped floating point. The most "pure" way sounds like using the aforementioned type system to give defaults, but have a way for the user to tweak the rules as needed. You're the designer, one of your jobs is to make these sorts of decisions for the user. Things like your i/o library probably have similar problems, I don't see why floating point is all that much different.