Nesting respond_to calls can lead to unexpected behavior, so it should be
avoided. Currently, the first respond_to format match sets the content-type
for the resulting response. But, if a nested respond_to occurs, it is possible
to match on a different format. For example:

    respond_to do |outer_type|
      outer_type.js do
        respond_to do |inner_type|
          inner_type.html { render body: "HTML" }
        end
      end
    end

Browsers will often include */* in their Accept headers. In the above example,
such a request would result in the outer_type.js match setting the content-
type of the response to text/javascript, while the inner_type.html match will
cause the actual response to return "HTML".

This change tries to minimize potential breakage by only raising an exception
if the nested respond_to calls are in conflict with each other. So, something
like the following example would not raise an exception:

    respond_to do |outer_type|
      outer_type.js do
        respond_to do |inner_type|
          inner_type.js { render body: "JS" }
        end
      end
    end

While the above is nested, it doesn't affect the content-type of the response.

Remove third party FIXME

AST Guide: install and migrate tasks needed in new app

Do nothing instead of raising an error when it’s called on an attached blob.

This line refers only to an upgrade situation, but same is need to setup AST in a new application.

[ci skip]

Reference Active Storage instead of third-party libraries in guide

[ci skip]

Paperclip has officially been deprecated, so we shouldn't mention it
anymore.

CarrierWave could still be referenced, as there are use cases where it
currently makes more sense, but for simplicity, I thought removing the
mention of third party libraries made sense. If we want to talk about
them, listing "alternatives" within the Active Storage guide could make
more sense.

Turn on performance based cops

This FIXME belongs to a code example that was imported from the
internet. As we aren't going to do anything about it, I prefer to remove
it so it stops from appearing on searches.

Update with_options.rb [ci skip]

explicit mapping for enum accepts a Hash not an Array, plus the example is using `.keys` which also exists on hash

Follow up of #33358 for SQLite3.

Prefer rails command over bin/rails

Rails guides are now served over https

http links will be redirected to the https version, but still better to
just directly link to the https version.

Use attr_reader/attr_writer instead of methods

method is 12% slower

Use flat_map over map.flatten(1)

flatten is 66% slower

Use hash[]= instead of hash.merge! with single arguments

merge! is 166% slower

See https://github.com/rails/rails/pull/32337 for more conversation

 [ci skip] Change the text color which wrapped by code tag.

Add strict argument checking to ActiveRecord callbacks

This ends up adding it to all save-related callbacks defined in `ActiveRecord::DefineCallbacks`, including e.g. `after_create`. Which should be fine: they didn't support `:on` in the first place.

[ci skip] Use consistent hash syntax in AR docs

[ci skip] fix typo in Active Record Associations guide

[ci skip] Tidy up formatting of (consecutive) examples

 [ci skip] Document render options

Complete renderer documentation

Fixes #28484

The consecutive verbatim blocks were being merged making the output look weird.

The examples with `.where` uses hash w/ symbol keys so it would be more consistent to also do this with `.new`.
Also from my experience the hash w/ symbol keys is more widely used with `where/new/create` etc. in ActiveRecord.

* Add implicit to path conversion to uploaded file

Ruby has a few implicit conversion protocols (e.g. `to_hash`, `to_str`,
`to_path`, etc.). These are considered implicit conversion protocols
because in certain instances Ruby (MRI core objects) will check if an
argument responds to the appropriate protocol and automatically convert
it when it does; this is why you can provide a `Pathname` instance into
`File.read` without having to explicitly call `to_s`.

```ruby
a_file_path = 'some/path/file.ext'
File.write a_file_path, 'String Path Content'
File.read a_file_path

a_pathname = Pathname(a_file_path)
File.write core_file, 'Pathname Content'
File.read a_file_path

core_file = File.new(a_pathname)
File.write core_file, 'File Content'
File.read core_file

tmp_file = Tempfile.new('example')
File.write tmp_file, 'Tempfile Content'
File.read tmp_file
```

So how does an uploaded file work in such cases?

```ruby
tmp_file = Tempfile.new('example')
File.write tmp_file, 'Uploaded Content'
uploaded_file = ActionDispatch::Http::UploadedFile.new(tempfile: tmp_file)
File.read uploaded_file
```

It fails with a `TypeError`:

    no implicit conversion of ActionDispatch::Http::UploadedFile into String

In order to make an uploaded file work it must be explicitly converted
to a file path using `path`.

```ruby
File.read uploaded_file.path
```

This requires any code that expects path/file like objects to either
special case an uploaded file, re-implement the path conversion protocol
to use `path`, or forces the developer to explicitly cast uploaded files
to paths. This last option can sometimes be difficult to do when such
calls are deep within the inner workings of libraries.

Since an uploaded file already has a path it makes sense to implement
the implicit "path" conversion protocol (just like `File` and
`Tempfile`). This change allows uploaded file content to be treated more
closely to regular file content, without requiring any special case
handling or explicit conversion for common file utilities.

* Note uploaded file path delegation in CHANGELOG

Clarify `railties/test/application/rake/notes_test.rb`

Use MethodCallAssertions instead of Mocha part 2

Step 6 in #33162

When using Mocha like this:

`ActiveRecord::Base.expects(:establish_connection).with(some_args)`,

the expectations created look something like this:

```
@expectations=
          [#<Expectation:0x561350d968e0 expected exactly once, not yet invoked: ActiveRecord::Base.establish_connection("adapter" => "mysql2", "database" => nil) >,
           #<Expectation:0x561350dab8f8 allowed any number of times, not yet invoked: ActiveRecord::Base.establish_connection(any_parameters) >,
           #<Expectation:0x561350dc30c0 allowed any number of times, not yet invoked: ActiveRecord::Base.connection(any_parameters) >]
```

Minitest mocking (and the way we use it in `MethodCallAssertions`)
expressly refuses to facilitate such permissiive expectations, insisting
that all calls be specified in the actual expected order.

This patch replaces such calls to `Mocha#expects` with
`ActiveSupport::Testing::MethodCallAssertions` and specifies all
expected calls in the epxected order.

A correct, but not obvious use of `ActiveSupport::Testing::MethodCallAssertions`, which might also have been part of #33337 or #33391.

Separate min and max threads count environment variable for puma configuration

Keep time_tag docs up-to-date.

Clarify example of the test `ActionController::HttpAuthentication::Token` [ci skip]

Follow up #33401, 5491f811.

ActiveRecord: limit() and primary_key

After 1996fbe2 `rails notes`
isn't the same as `rake notes`.
Since that, we should test `rake routes` instead of `rails notes` in
`railties/test/application/rake/notes_test.rb` file.
So I changed all occurrences of `rails routes` to `rake routes` in that file,
and added assertions about deprecation warning of using `rake notes`.
It will help to figure out that we should remove
`railties/test/application/rake/notes_test.rb` entirely in favour of
`railties/test/commands/notes_test.rb` that was added
in 1996fbe2.