Prior to this commit, when a translation key indicated that the
translation text was HTML, the value returned by `I18n.translate` would
always be marked as `html_safe`.  However, the value returned by
`I18n.translate` could be an untrusted value directly from
`options[:default]`.

This commit ensures values directly from `options[:default]` are not
marked as `html_safe`.

Fix TranslationHelper#translate handling of Hash defaults

A string S matches ([.]|\b)html if an only if matches \bhtml:

  * If S matches [.]html, then it matches \bhtml.

  * If S matches \bhtml, then it matches \bhtml.

Reciprocally:

  * If S matches \bhtml, then it matches ([.]|\b)html.

The character class can be removed, and since we are on it we remove the
group too so that it is clear to a reader of the code that there is no
grouping going on.

References #35166.

- Use `\z` instead of `$`
- Use character class instead of alternation
- Optimize alternation order

In Ruby 2.3 or later, `String#+@` is available and `+@` is faster than `dup`.

```ruby
# frozen_string_literal: true

require "bundler/inline"

gemfile(true) do
  source "https://rubygems.org"

  gem "benchmark-ips"
end

Benchmark.ips do |x|
  x.report('+@') { +"" }
  x.report('dup') { "".dup }
  x.compare!
end
```

```
$ ruby -v benchmark.rb
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]
Warming up --------------------------------------
                  +@   282.289k i/100ms
                 dup   187.638k i/100ms
Calculating -------------------------------------
                  +@      6.775M (± 3.6%) i/s -     33.875M in   5.006253s
                 dup      3.320M (± 2.2%) i/s -     16.700M in   5.032125s

Comparison:
                  +@:  6775299.3 i/s
                 dup:  3320400.7 i/s - 2.04x  slower

```

If the options passed in don't have a default key, there's no point in
creating an array from those empty results when we can just go straight
to creating an empty array.

Benchmarks:
```ruby
master_version with false
{:FREE=>-2497, :T_STRING=>52, :T_ARRAY=>2000, :T_HASH=>1000, :T_IMEMO=>1}
master_version with true
{:FREE=>-3001, :T_ARRAY=>2000, :T_HASH=>1000}
fast_version with false
{:FREE=>-1001, :T_ARRAY=>1000}
fast_version with true
{:FREE=>-3001, :T_ARRAY=>2000, :T_HASH=>1000}
Warming up --------------------------------------
master_version with false
                       104.985k i/100ms
master_version with true
                       118.737k i/100ms
fast_version with false
                       206.013k i/100ms
fast_version with true
                       107.005k i/100ms
Calculating -------------------------------------
master_version with false
                          1.970M (±24.6%) i/s -      8.924M in   5.010302s
master_version with true
                          2.152M (±12.4%) i/s -     10.686M in   5.051588s
fast_version with false
                          5.613M (±19.6%) i/s -     26.782M in   5.003740s
fast_version with true
                          2.027M (±15.8%) i/s -      9.951M in   5.065670s

Comparison:
fast_version with false:  5613159.2 i/s
master_version with true:  2152354.4 i/s - 2.61x  slower
fast_version with true:  2027296.0 i/s - 2.77x  slower
master_version with false:  1969824.9 i/s - 2.85x  slower
```

Benchmark code:
```ruby
begin
  require "bundler/inline"
rescue LoadError => e
  $stderr.puts "Bundler version 1.10 or later is required. Please update
                your Bundler"
  raise e
end

gemfile(true) do
  source "https://rubygems.org"

  gem "benchmark-ips"
  gem "rails"
end

def allocate_count
  GC.disable
  before = ObjectSpace.count_objects
  yield
  after = ObjectSpace.count_objects
  after.each { |k,v| after[k] = v - before[k] }
  after[:T_HASH] -= 1 # probe effect - we created the before hash.
  GC.enable
  result = after.reject { |k,v| v == 0 }
  GC.start
  result
end

def master_version(key)
  Array({}.delete(:default)).compact
end

def fast_version(key)
  if key
    Array({}.delete(:default)).compact
  else
    []
  end
end

def test
  puts "master_version with false"
  puts allocate_count { 1000.times { master_version(false) } }
  puts "master_version with true"
  puts allocate_count { 1000.times { master_version(true) } }
  puts "fast_version with false"
  puts allocate_count { 1000.times { fast_version(false) } }
  puts "fast_version with true"
  puts allocate_count { 1000.times { fast_version(true) } }

  Benchmark.ips do |x|
    x.report("master_version with false")  { master_version(false) }
    x.report("master_version with true") { master_version(true) }
    x.report("fast_version with false")    { fast_version(false) }
    x.report("fast_version with true")   { fast_version(true) }
    x.compare!
  end
end

test
```

This gets called many times for each virtual_path, creating a new string
each time that `translate` is called. We can memoize this so that it
only happens once per virtual_path instead.

This basically reverts c4d1a4ef

This reverts commit 3420a145, reversing
changes made to afb66a5a.

Plus a couple of related ActionPack patches.

Regexp#match? should be considered to be part of the Ruby core library. We are
emulating it for < 2.4, but not having to require the extension is part of the
illusion of the emulation.

The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.

Where appropriate, prefer the more concise Regexp#match?,
String#include?, String#start_with?, or String#end_with?

`I18n.translate` helper will wrap the missing translation keys
in a <span> tag only if `debug_missing_translation` configuration has
a truthy value. Default value is `true`. For example in `application.rb`:

    # in order to turn off missing key wrapping
    config.action_view.debug_missing_translation = false

It's already represented in the key name. Demonstrate with a test.

Also test that the default isn't output.

The documentation previously stated that calling `translate(".foo")` was
equivalent to calling `I18n.translate("people.index.foo")` which is
incorrect due to the various other functions of the `translate` view
helper. This has been fixed.

Additionally, a note about forcing the view helper to re-raise
exceptions was added to the section detailing the handling of missing
translations.

Other cleanup includes:

* Consistent formatting of code
* Stop indenting bulleted list as a code sample
* Tighten some of the language
* Wrap at 80 characters.

4.2.1 introduced a change to the way `translate`/`t` works with an
option of `default: [[]]`. In 4.2.0, this would give a default value of
`[]`, but in 4.2.1, it leads to a missing translation.

`default: [[]]` is again allowed for cases where a default of `[]` is
needed.

This addresses GitHub issue 19640.

Strip nils out of default translations. Fixes #19419

The previous version of rails(4.2.0) you can pass objects
to the default option of translation helper.

For example:

```ruby
  t('foo', default: 1)
```

But on rails 4.2.1 version this kind of use stopped to work,
because started only to accept String types.

Now with this fix we can use orther value types on this
helper again.

Previously default translation keys that didn't end in `_html`, but came
after a missing key that ended in `_html` were being returned as
html_safe. Now they are not. Fixes #18257

Previously, when the `:raise` options was set to `false`, it would get overwritten to `true`, preventing custom exception handlers to be used.

not required include ActionView::Helpers::TagHelper in test as well

`options[:default]` and `options[:raise]` can be mistakenly added to the `options` hash. This can be a problem if you're reusing the same object.

Add a config to setup whether raise exception for missing translation or
not.