Replace javascript highlighting in guides with Rouge [ci skip]

Replace javascript highlighting using Prism with the Rouge markdown
highlighter. Uses the github theme.

Docs: config.hosts: details re: regexp anchors

Type cast extra select for eager loading

It is not a big issue for common types, since type casting in master
branch is much improved, but strictly speaking eager loading should
respect column types from database like as `find_by_sql` also does.

https://github.com/rails/rails/blob/97c34a55fa0f4e8d51504bd137f6e82155336d9a/activerecord/lib/active_record/querying.rb#L46-L52

Fixes #39605.

fix misleading section on associations guide

[ci skip]

Remove broken responsive-tables JS, improving mobile readability & accessibility [ci skip]

Add link to forum

In addition remove SO link

Follow up to https://github.com/rails/homepage/pull/140

[CI skip]

Added docs for client-side logger

Change default HTTP status to 308 for ActionDispatch::SSL. 

308 status code introduced in https://tools.ietf.org/html/rfc7538
preserves the request method unlike 301 status code which would convert
POST requests to GET.

Resolve attribute alias for counter cache column

The lack of ability for making this has resolved by #39496 and #39530.

Support `where` with comparison operators (`>`, `>=`, `<`, and `<=`)

`PredicateBuilder.references` and `PredicateBuilder#build_from_hash`
does similar processing and both requires stringify keys for passed hash
argument. This consolidates stringify keys to avoid extra string
allocation in `PredicateBuilder`.

```ruby
posts = Post.order(:id)

posts.where("id >": 9).pluck(:id)  # => [10, 11]
posts.where("id >=": 9).pluck(:id) # => [9, 10, 11]
posts.where("id <": 3).pluck(:id)  # => [1, 2]
posts.where("id <=": 3).pluck(:id) # => [1, 2, 3]
```

From type casting and table/column name resolution's point of view,
`where("create_at >=": time)` is better alternative than `where("create_at >= ?", time)`.

```ruby
class Post < ActiveRecord::Base
  attribute :created_at, :datetime, precision: 3
end

time = Time.now.utc # => 2020-06-24 10:11:12.123456 UTC

Post.create!(created_at: time) # => #<Post id: 1, created_at: "2020-06-24 10:11:12.123000">

# SELECT `posts`.* FROM `posts` WHERE (created_at >= '2020-06-24 10:11:12.123456')
Post.where("created_at >= ?", time) # => []

# SELECT `posts`.* FROM `posts` WHERE `posts`.`created_at` >= '2020-06-24 10:11:12.123000'
Post.where("created_at >=": time) # => [#<Post id: 1, created_at: "2020-06-24 10:11:12.123000">]
```

This has had no effect since 771a802c.

Error entries appear in the log when we request ActiveStorage
controllers (`ActiveStorage::Representations::ProxyController#show`,
`ActiveStorage::Blobs::ProxyController#show`).

These entries look like: "Couldn't find template for digesting:
active_storage/representations/proxy/show".

These controllers use the method
`ActionController::ConditionalGet#http_cache_forever`,
and therefore `ActionController::ConditionalGet#combine_etags` method,
and therefore `ActionController::EtagWithTemplateDigest` module via
`etaggers` array.

`ActionController::EtagWithTemplateDigest` module requires a template
(view).

We have no views in ActiveStorage, so `EtagWithTemplateDigest` is
now turned off in ActiveStorage controllers by
`etag_with_template_digest` class attribute.

Add better responsive CSS for tables in guides

Fix borders & breakpoints for responsive tables

Add table fixes to RTL stylesheets

Use 480px breakpoints, remove outdated CSS

Records loaded from join queries are no longer automatically marked as
read-only since aff928ba.

Followup to 978421abd83d45b72e299f50a4fb324fcbdb3e00.

This reverts commit 05060ddb.

Tags are per-fiber, so they can't be cached in an instance variable.

Use segment instead of fragment in docs [ci-skip]

Refactor MemoryStore to use Hash ordering rather than key access times

Backward compatibility to work `Marshal.load(legacy_record.dump)` for MySQL

This is mainly to simplify the code and use less memory, as large hash can use quite a lot:

```ruby
>> ObjectSpace.memsize_of(1000.times.map { |i| [i, i]}.to_h)
=> 28768
>> ObjectSpace.memsize_of(10_000.times.map { |i| [i, i]}.to_h)
=> 458848
```

The performance is mostly not impacted, if not slightly better:

```ruby
require 'benchmark/ips'
require 'active_support/all'
@store = ActiveSupport::Cache::MemoryStore.new
@store.write("small", "small")
Benchmark.ips do |x|
  x.report("read:miss") { @store.read("miss") }
  x.report("read:small") { @store.read("small") }
  x.report("write:small") { @store.write("small", "small") }
end
```

6.0.3.2:
```
Warming up --------------------------------------
           read:miss    42.466k i/100ms
          read:small    25.315k i/100ms
         write:small    17.826k i/100ms
Calculating -------------------------------------
           read:miss    426.923k (± 1.9%) i/s -      2.166M in   5.074890s
          read:small    248.518k (± 2.7%) i/s -      1.266M in   5.097049s
         write:small    180.388k (± 1.6%) i/s -    909.126k in   5.041238s
```

This branch:
```
Warming up --------------------------------------
           read:miss    42.040k i/100ms
          read:small    28.364k i/100ms
         write:small    19.361k i/100ms
Calculating -------------------------------------
           read:miss    417.814k (± 2.1%) i/s -      2.102M in   5.033186s
          read:small    278.950k (± 2.8%) i/s -      1.418M in   5.088135s
         write:small    193.384k (± 1.8%) i/s -    968.050k in   5.007446s
```

Improve the docs for ordered options [ci skip]