This is an alternate implementation of #20966.

[Sean Griffin & presskey]

Encode the email address as prescribed in RFC 6068 section 2.

Deep down in the association internals, we're calling `destroy!` rather
than `destroy` when handling things like `dependent` or autosave
association callbacks. Unfortunately, due to the structure of the code
(e.g. it uses callbacks for everything), it's nearly impossible to pass
whether to call `destroy` or `destroy!` down to where we actually need
it.

As such, we have to do some legwork to handle this. Since the callbacks
are what actually raise the exception, we need to rescue it in
`ActiveRecord::Callbacks`, rather than `ActiveRecord::Persistence` where
it matters. (As an aside, if this code wasn't so callback heavy, it
would handling this would likely be as simple as changing `destroy` to
call `destroy!` instead of the other way around).

Since we don't want to lose the exception when `destroy!` is called (in
particular, we don't want the value of the `record` field to change to
the parent class), we have to do some additional legwork to hold onto it
where we can use it.

Again, all of this is ugly and there is definitely a better way to do
this. However, barring a much more significant re-architecting for what
I consider to be a reletively minor improvement, I'm willing to take
this small hit to the flow of this code (begrudgingly).

Remove unused rule and task from activerecord

We need stricter locking before we can unload

this fixes a failing test case

The note regarding the `_prefix` and `_suffix` options is no longer
useful since they were renamed specifically for this purpose.

Also the given example doesn't show what these options enable and in
which case they are really useful (when there are conflicting values
for instance).

Refs #20999.

[Godfrey Chan & Robin Dupret]

Rename the enum_prefix and enum_suffix options to _prefix and _suffix

This makes it more clear that they are reserved keywords and also it
seems less redundant as the line already starts with the call to the
`enum` method.

Fixes documentation typo.[ci skip]

Documentation had extra colon after keyword.

Don't apply locking around basic #load / #require

That's outside our remit, and dangerous... if a caller has their own
locking to protect against the natural race danger, we'll deadlock
against it.

* only test the upgrade path,
* add test to verify non upgrades can’t preempt,
* add reentrancy assertion.

Now that we have encoding strategies, we can just walk the params hash
once to encode as HWIA, and remove nils.

we'll refactor deep munge mostly out of existence shortly

This should have been done along with 8f8ccb99

this just pushes the conditional in to the case / when so we can switch
to method dispatch later

there is no reason to `convert_hashes_to_parameters` with an assignemt
flag.  The caller knows whether or not it wants the value assigned.  We
should just change the uncommon case (not writing to the underlying
hash) to just call the conversion method and return that value.

only hashes are converted to parameter objects, so lets add a branch for
them.  This also removes a is_a? test for Parameters so we can be
abstracted from the class.

fix rails tests

Extra caller details added to ActiveRecord::RecordNotFound

ActiveRecord::RecordNotFound modified to store model name, primary_key
and id of the caller model. It allows the catcher of this exception to make
a better decision to what to do with it. For example consider this simple
example:

    class SomeAbstractController < ActionController::Base
      rescue_from ActiveRecord::RecordNotFound, with: :redirect_to_404

      private def redirect_to_404(e)
        return redirect_to(posts_url) if e.model == 'Post'
        raise
      end
    end

add system! to fail fast in bin/setup

remove `web-console` from API app generated Gemfile

Deprecate the keys for association `restrict_dependent_destroy` errors in favor of new key names

Previously `has_one` and `has_many` associations were using the
`one` and `many` keys respectively. Both of these keys have special
meaning in I18n (they are considered to be pluralizations) so by
renaming them to `has_one` and `has_many` we make the messages more
explicit and most importantly they don't clash with linguistical
systems that need to validate translation keys (and their
pluralizations).

The `:'restrict_dependent_destroy.one'` key should be replaced with
`:'restrict_dependent_destroy.has_one'`, and
`:'restrict_dependent_destroy.many'` with
`:'restrict_dependent_destroy.has_many'`.

[Roque Pinel & Christopher Dell]

Ensure that microsecond precision is only used for versions of mysql that support it.

Remove unnecessary `dup` from Mapper `add_route`

Specifically, clean up if the thread is killed while it's blocked
awaiting the lock... if we get killed on some other arbitrary line, the
result remains quite undefined.

I accidentally discovered `assert_threads_not_stuck` couldn't fail, so
the simplest solution was to prove they're all now working in both
directions.

titleizing the New Link

If the thread isn't yet holding any form of lock, it has no claim over
what may / may not run while it's blocked.

Fix minor typo in testing guide [ci skip]