Parameter ownership is generally type-driven in Swift already. I would expect that we would model aliased borrows and mutations as new kinds of parameter ownership that would distinguished in function types, probably written something like borrowing(aliased) and inout(aliased) (or nonmutating(aliased) and mutating(aliased) on methods).
Having an abstract reference to non-aliased storage (e.g. a non-aliased borrowing parameter) is a guarantee that nothing externally aliases that storage. It does not forbid a function from locally forming its own aliases to the storage. Such local aliases are fine because the model for them preserves memory safety (in the absence of concurrency) by only allowing instantaneous accesses to the actual memory: copies and overwrites. The compiler just needs to ensure that the lifetime of such aliases does not overlap any accesses that would conflict with them.
Therefore, a non-aliased borrow or mutation can safely be "downgraded" to an aliased borrow or mutation as long as nothing else is happening to the storage during that time. In particular, this means there is a natural subtype relationship in which:
(borrowing(aliased) T) -> R is a subtype of (borrowing T) -> R and
(inout(aliased) T) -> R is a subtype of (inout T) -> R.
The reverse is not true: you cannot safely "upgrade" an aliased reference to a non-aliased reference. It is possible to emulate this by copying the value, but of course this requires the type to be copyable, and it has performance and semantic consequences. We would not have a function subtyping relation in this direction, both because of the copyability restriction and because it would create a new cycle in the subtyping relation, which is highly undesirable. However, I do think we should probably allow this emulation to be done implicitly during calls.
For C++, I would expect that we'd import this and reference parameters as "value" parameters with these new kinds of ownership, at least when the parameter is known to not escape.
For protocol requirements and unspecialized generics, this is all fairly straightforward. We have no mechanism in the language for generically abstracting over parameter ownership; the ownership of a specific parameter is always known statically. For protocol requirements, this comes from the declaration of the requirement. An unadorned protocol requirement like mutating func foo() declares that it takes self as an unaliased mutation. We can reasonably choose to allow an implementation of the requirement to take self as an aliased mutation, which ultimately simply does the subtyping downgrade discussed above; but when we call an unknown function through the protocol requirement, we must assume that the caller requires an unaliased mutation, and so such a function cannot be called on aliased storage.
So, for example, Iterable's makeBorrowingIterator requirement takes an unaliased borrow of self, and the iterator it returns is valid for this duration. A witness to this requirement may therefore assume that self is not aliased during the iteration. In particular, C++ types like std::vector can directly vend their element span from the iterator and be confident that it will not be invalidated. The flip side of this is that makeBorrowingIterator() cannot be called at all on a vector that is held in aliased storage (unless we can somehow prove a lack of aliasing, or create it by a temporary copy).