* Add ddl persistence support for mysql

Since mysql does not have the concept of a (non-select) statement timeout,
it is necessary to use core.async to monitor the create table as select
statement manually. While mariadb does support a general statement
timeout, this will work for both vendors. There are some race conditions
here but in the context of persistence, this is ok. Mainly, the timeout
could hit right as the create table finishes. If that happens, the
statement will not be killed (because it was closed when finished), the
table will be created, but the function will throw a timeout exception.
In the context of persistence, this is ok since persisted-info will
remain inactive and the next refresh will drop the table and try again.

The other aspect to consider is that mysql doesn't rollback ddl changes.
So we have to manually keep track of what was done when testing the db
and undo the steps on failure. This isn't perfect, as the undo itself
could throw an exception, thus leaving the schema or test table in place,
that should only happen if a role has a create table but not a delete
table grant. In any event, if a our schema or test table sticks around,
they could be removed manually by a dba, or ignored without harm.

* Handle integrating mysql, and make sure exceptions are logged

* Add tests for execute-with-timeout

* Fix linters

* Switch to async/thread because reflection hints are lost by a/go and it's better not to do io in go-blocks

* Fix test

* Run the remaining E2E groups using GitHub Actions

* Remove Snowplow from CCI

* Remove waiting for databases from CCI

* Remove Cypress jobs from CCI

* Remove `fe-deps` from CCI

* Remove `tester` executor from CCI

* Remove all frontend-related from CCI

* Remove static viz bundle from CCI

* Remove E2E checksum from CCI

* Remove frontend checksum from CCI

* Trigger CI run #1

* Trigger CI run #2

* Trigger CI run #3

* Trigger CI run #4

* Trigger CI run #5

* ValidationError package created

* ValidationError imports updated

* add exceeded_limit column and set it to true when values of a list field exceed our defined limits

* move exceeded_limit to has_more_values in metabase_fieldvalues

* make fieldvalues search not do in-memory search if has_more_values=true

* resolve Noah's comments and make the comments clearer

* Offer transparent background in embedding

* Remove nighttime mode toggle for transparent embedded dashboard

* Refactor hasNightModeToggle

* Optimize checkerboard file size

* Add Percy to the main E2E workflow

* Ignore unit tests

* Delete Percy workflow

* Do not run Percy tests on Cypress changes only

* Check whether visual regression tests should run at all

* fix subscriptions and alerts

* review

* specs

* Updating Dashboard Action Menu, Moving bookmark action

* Fixing Tests

* Add `can-manage` property to `Database` types

* Only show enable/disable caching with DB access

* Rename `tooltip` which is not a tooltip anymore

* Remove redundant variable

* Move model cache section to OSS

* Don't handle "off" state as it won't be shown

* Tweak copy

* Join slack channels with slack-id

Fixes https://github.com/metabase/metabase/issues/23229

We upload images to a channel and then send messages to the desired
channel referencing those images from the channel we uploaded. But the
slack bot must be in the channel to upload images.

We handle this in `slack/upload-image!` where we watch the error message
and join the channel if we recognize that is our issue. This special
upload channel is set in the admin section when setting up, typed in by
a human.

Slack now requires us to use the internal id of the channel when
joining. IE we used to use "metabase_files" but now we need to use
something like "C87LQNL0Y23". But we do not have this information and we
don't want humans to have to look this up.

SOLUTION:
change our cache. We currently just get a list of channels and users
```
["#general" "@dan" ...]
```

Change this to
```
{:version 2,
 :channels [{:display-name "#random",
             :name "random",
             :id "CT2FNGZSRPL",
             :type "channel"}
            {:display-name "#general",
             :name "general",
             :id "C87LQNL0Y23",
             :type "channel"}
            {:display-name "@dan",
             :type "user",
             :name "dan",
             :id "UR65C4ZJVIW"}
            ...]}
```

Now we have slack internal ids present. When we attempt to join the
slack channel, look for this id and attempt to use that.

This has some knock-on effects. The UI still lists the channels in a
channel picker when sending pulses. The list sent over the wire still
mimics the previous shape (a flat list) and the choice is still the
human readable name.

In the future we should switch over to using the stable ids rather than
solely channel names. Channel names can be renamed.

I didn't go down this route because of the files channel. It is set at
setup before we have a channel list. We could do some kind of run time
migration but it is difficult because it would change the type of
`slack-files-channel` from string to :json to handle the more complex
type. Or perhaps we could make another setting to hold the json form and
set that when we can positively identify things.

In either case, these changes were not required yet to fix our slack
issue. We just upgrade the information we have about slack channels,
downgrade it when it hits the wire so the UI needs no changes, and use
the extra information in the one spot where we need it.

The cache is populated at startup and every four hours after that. So we
do not need to worry about the old cache shape. If the new code is
running, its the new cache.

* Send #channel and @user forms over wire

We store `{"channel": "#slack-pulses"}` in the pulse_channel.details
column so we should keep those types of values around.

We use the bare portion ("slack-pulses") rather than with the hash on it
so we seem to be mixing usernames and channels. But these sets are
distinct and you cannot create a channel with the same name as a
user. Also, channel names are lowercase while channel-ids are uppercase
so those are also non-overlapping sets.

* Put slack token so slack reports as configured

* Errant tap>

* Alignment and docstring fixes

* Remove slack-cache version information

remove the `:version 2` from the cache. We are always in charge of the
cache, and we compute it on startup so there's little risk of other data
shapes being present.

* fix tooltip overflow

* explicit default for preventOverflow

* check ci

* show field options in popover

* application-colors have new keys that may be added via the getter

Some colors previously had multiple usage contexts. For example, `accent1` was used both in charts and other parts of
the summarize UI. Now, those notions are being separated, so `accent1` remains a valid key, and `summarize` is a new
valid key. To make sure behaviour remains the same for existing whitelabel users who may have set these keys, when
such a key exists, it is 'split' by the getter.

For example, if the existing application-colors json contains `accent1`, the getter will add a new key `summarize`
with the same value as `accent1`, but only if `accent1` already exists, otherwise it does nothing. This is also true
for keys `brand`, which adds `accent0`, and `accent7`, which adds `filter`

* Make application colors getter make change only once

* Premium feature flag for test