References in a language where everything is a reference?

Disentangling variable semantics from calling conventions

First off, I want to caution against confusing the semantics of variables and types with semantics of parameter passing. In Lisp (and Python, and for most types in Java, and for selected types in C#), variables have reference semantics, i.e. the rule that "variables hold references and assignment copies the reference". Reference semantics are particularly common in dynamically typed languages, simply because the assigned value might use a different amount of memory than the original value for its underlying representation; since indirection is generally required anyway, it may as well be used to avoid unnecessary copying.

So-called "pass-by-sharing" or "pass-by-identity" is really pass by value in a context where the passed value has reference semantics. In an earlier era, people thought the terminology "pass by value" was confusing for such languages; but as originally defined, it's a perfect fit. Another more modern term is "pass by assignment" - meaning that passing an argument to a parameter works the same way as assigning a value to a variable.

Evaluating reference types in C++

As for the main question: true pass by reference is quite rare in contemporary languages, and the C++ implementation is weird and arguably not quite the same thing. (I'm not familiar with Algol 68, but I'm inferring from your description that it works substantially the same way as in C++). Conceptually, "pass by reference" should be a parameter passing convention, but C++ models this by making "references" into a separate type category (and further confuses things by adding this to a language that already has "pointers", which in generic computer science discussion would be considered a form of "reference").

This approach accomplishes the goal of enabling "operator overloading" for assignment. Perhaps a more classic test - which can be applied in a more language-agnostic way - is that this scheme allows for writing a "swap" function that swaps the values of two of the caller's variables. This can't happen with pass-by-value, even when the values have reference semantics, because the function is given different references. But C++ causes assignments to the reference, to affect the referred-to original value, rather than changing the referent ("re-seating" the reference, in the terminology of the C++ FAQ Lite).

And that causes all manner of problems when one tries to develop a proper mental model. C++ references can to some extent be treated like const pointers, except that they can't legally be NULL or dangling, and attempting to use them inserts indirection into the code that isn't actually there, and you can write an assignment even though it's const because it actually assigns to the indirected target. But on the other hand, there might not actually be a value there at all after even the most basic compiler optimizations. Unless the reference is a member of a data structure somewhere, in which case it might have to exist just to take up space and have an address (which must be distinct from the addresses of other members).

It's really a quite complex idea. And that's without even touching on the issue of "bindings and closures", as you mention it - i.e., the lifetime of the referent vs. its references. This is especially complex without garbage collection, but I expect it would still be a massive headache in a garbage-collected language that implemented references this way. C++ ends up needing special rules like this one and that one. I'm afraid I can't tell you anything useful about how to implement that sort of thing.

Discussion and alternatives

Personally, I don't think that contemporary languages with reference-semantics variables benefit much, if at all, from support for pass by reference. Users can always just wrap the value in a container, which is passed by value and modified by the function; or the calling code can assign back whatever returned value. Being able to modify the passed-in object is generally sufficient for typical programming idioms; things that can't work this way often have separate support (for example, Python has a multiple assignment idiom that makes a theoretical swap function sound clunky and useless).

I suspect that a major reason why true pass-by-reference has become so rare is because it can make programs very difficult to reason about, by breaking the encapsulation of functions. It's already considered poor practice to have "mutable shared state" without well-defined boundaries - for example, to have functions that communicate by modifying a global variable. Re-assigning a variable from an enclosing lexical scope (rather than, say, an attribute of an object, within the code for a method) is already a major source of bugs. True pass by reference entails something like the dynamically scoped equivalent of that - modifying a variable from the caller, i.e., an enclosing dynamic scope. It effectively introduces a dynamic scoping concept into an otherwise lexically scoped language. Dynamic scoping is also an increasingly rare language feature, so this could easily be counted as another strike against pass by reference.

That said, if you really want the kind of flexibility and semantics that you describe, I would strongly encourage you to instead consider how C# implements pass-by-reference. C# allows for types that have value semantics as well as those with reference semantics - called "value types" and "reference types", respectively, in documentation. (I couldn't use these terms before, since "reference type" means something fundamentally different in C++.)

More importantly for the current discussion, it also allows for passing either by reference or by value, as well as supporting "out parameters" (functionally pass by reference, except that the passed-in value may not be used and thus is not required to be initialized). To avoid surprises (and perhaps ease compilation - I don't know any relevant implementation details), the calling convention must be marked on both the function and the caller.

And, crucially, pass by reference is treated as a true calling convention, and not a property of types. You can pass the same value by value or by reference to different functions, and you can do this with both value types and reference types. It's especially useful for value types, since it allows for modifying the passed-in value as well as replacing it. (Passing a reference type by value allows for modification, but not replacement. But keep in mind that such modifications can be "seen" by other potential referers, too, whereas replacement would not be.)