After upgrade CH from 20.8 to 21.3 I noticed RAM used by dictionary with `hashed` layout was increased exactly in **4** times.

OS: Ubuntu 20.04
Processor: AMD EPYC 7502P 32-Core Processor
RAM: 252 GB

`<dictionaries_lazy_load>false</dictionaries_lazy_load>
`

In 20.8 release CH was using less memory for dictionaries with `hashed` layout.
The problem was not detected for dictionaries with `ComplexKeyHashed` layout. But they have a small amount of data (up to 500 MB).
After server restart with 20.8 version memory usage is increasing up to 30 GB (all dictionaries RAM usage) step by step during dictionaries loading.
After server restart with 21.3 version memory usage is increasing up to 112 GB almost immediately and then decreasing to 91 GB.

Maybe it's a consequence after #18236

20.8 version dictionary
```
┌─status─┬─type───┬─key────┬─attribute.types─┬─element_count─┬─formatReadableSize(bytes_allocated)─┐
│ LOADED │ Hashed │ UInt64 │ ['Float64']     │     428492347 │ 16.00 GiB                           │
└────────┴────────┴────────┴─────────────────┴───────────────┴─────────────────────────────────────┘
```

21.3 version dictionary
```
┌─status─┬─type───┬─key────┬─attribute.types─┬─element_count─┬─formatReadableSize(bytes_allocated)─┐
│ LOADED │ Hashed │ UInt64 │ ['Float64']     │     428492347 │ 64.00 GiB                           │
└────────┴────────┴────────┴─────────────────┴───────────────┴─────────────────────────────────────┘
```

Dictionaries with the same scheme but another amount of data also have this problem.
{
    auto create_layout = [](const std::string & full_name,
                             const DictionaryStructure & dict_struct,
                             const Poco::Util::AbstractConfiguration & config,
                             const std::string & config_prefix,
                             DictionarySourcePtr source_ptr,
                             bool sparse) -> DictionaryPtr
    {
        if (dict_struct.key)
            throw Exception{"'key' is not supported for dictionary of layout 'hashed'", ErrorCodes::UNSUPPORTED_METHOD};
        if (dict_struct.range_min || dict_struct.range_max)
            throw Exception{full_name
                                + ": elements .structure.range_min and .structure.range_max should be defined only "
                                  "for a dictionary of layout 'range_hashed'",
                            ErrorCodes::BAD_ARGUMENTS};
        const auto dict_id = StorageID::fromDictionaryConfig(config, config_prefix);
        const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
        const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
        return std::make_unique<HashedDictionary>(dict_id, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty, sparse);
    };
    using namespace std::placeholders;
    factory.registerLayout("hashed",
        [=](auto && a, auto && b, auto && c, auto && d, DictionarySourcePtr e){ return create_layout(a, b, c, d, std::move(e),  false); }, false);
    factory.registerLayout("sparse_hashed",
        [=](auto && a, auto && b, auto && c, auto && d, DictionarySourcePtr e){ return create_layout(a, b, c, d, std::move(e),  true); }, false);
}
}