### Elasticsearch Version

8.0.0

### Installed Plugins

_No response_

### Java Version

_bundled_

### OS Version

macOS 12.2.1

### Problem Description

The [MinHash](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-minhash-tokenfilter.html) token filter has four configurable parameters: `bucket_count`, `hash_count`, `hash_set_size`, and `with_rotation`. Currently both `bucket_count` and `hash_set_size` have no effect, because there appears to be a bug in the code that interfaces with the underlying Lucene class.

Snippet from [MinHashTokenFilterFactory](https://github.com/elastic/elasticsearch/blob/524d1ea757938cc4a05eb596dc0e93f888933d50/modules/analysis-common/src/main/java/org/elasticsearch/analysis/common/MinHashTokenFilterFactory.java):

    Map<String, String> settingMap = new HashMap<>();
    if (settings.hasValue("hash_count")) {
        settingMap.put("hashCount", settings.get("hash_count"));
    }
    if (settings.hasValue("bucketCount")) {
        settingMap.put("bucketCount", settings.get("bucket_count"));
    }
    if (settings.hasValue("hashSetSize")) {
        settingMap.put("hashSetSize", settings.get("hash_set_size"));
    }
    if (settings.hasValue("with_rotation")) {
        settingMap.put("withRotation", settings.get("with_rotation"));
    }

Notice the camel-case `bucketCount` and `hashSetSize` in the `hasValue` lines. These should be `bucket_count` and `hash_set_size`, since those are the parameter names that would appear (and be fetched on the following lines) from the `settings` object. It looks like this bug was introduced with commit [524d1ea757938cc4a05eb596dc0e93f888933d50](https://github.com/elastic/elasticsearch/commit/524d1ea757938cc4a05eb596dc0e93f888933d50#diff-698ceed90738735edfc93b7e9c6d2d17808733c12277672c8f0d0ee3cfe1a1f2) on 21 Sep 2021.

### Steps to Reproduce

Here are two examples that demonstrate the issue with the `bucket_count` parameter, and which could potentially be used as the basis for additional [tests](https://github.com/elastic/elasticsearch/blob/26c86871fc091900952e88e252c36fbfedf8d5fa/modules/analysis-common/src/test/java/org/elasticsearch/analysis/common/MinHashFilterFactoryTests.java), as well as a third example that could be used to test the `hash_set_size` parameter.

**Example 1**
Define a [custom analyzer](https://www.elastic.co/guide/en/elasticsearch/reference/current/configuring-analyzers.html) that includes a MinHash token filter configured with a single hash function and a single bucket:

    PUT my-index-1
    {
      "settings": {
        "analysis": {
          "analyzer": {
            "my_analyzer": { 
              "type": "custom",
              "tokenizer": "standard",
              "filter": ["my_minhash_filter"]
            }
          },
          "filter": {
            "my_minhash_filter": {
              "type": "min_hash",
              "hash_count": 1,
              "bucket_count": 1,
              "hash_set_size": 1,
              "with_rotation": true
            }
          }
        }
      }
    }
    
    POST my-index-1/_analyze
    {
      "analyzer": "my_analyzer",
      "text": "test"
    }

Expected output: `{ "tokens": [<1 token>] }`
Observed output: `{ "tokens": [<512 identical tokens>] }`

The reason for the 512 tokens is that the single input token is being hashed and placed into one of the hash function's 512 buckets (the default number), and because rotation is enabled that hashed token is being used as output from the empty buckets as well. If the `bucket_count: 1` configuration had worked, we would only have seen a single output token.

**Example 2**
With _k_ hash functions each paired with a single bucket (and hash set size 1), we should get _k_ MinHash tokens regardless of the number of input tokens:

    ...
          "filter": {
            "my_minhash_filter": {
              "type": "min_hash",
              "hash_count": 1,
              "bucket_count": 1,
              "hash_set_size": 1,
              "with_rotation": false
            }
          }
    ...
    
    POST my-index-1/_analyze
    {
      "analyzer": "my_analyzer",
      "text": "another, longer test"
    }

Expected output: `{ "tokens": [<1 token>] }`
Observed output: `{ "tokens": [<3 tokens>] }`

The three input tokens are being placed into three distinct buckets (in this case there are no clashes), and since rotation is disabled three tokens are being returned. 

**Example 3**
Once the bug has been fixed and the bucket count can be set, a simple test for the `hash_set_size` parameter might be:

    ...
          "filter": {
            "my_minhash_filter": {
              "type": "min_hash",
              "hash_count": 1,
              "bucket_count": 1,
              "hash_set_size": 2,
              "with_rotation": false
            }
          }
    ...
    
    POST my-index-1/_analyze
    {
      "analyzer": "my_analyzer",
      "text": "another, longer test"
    }

Expected output: `{ "tokens": [<2 tokens>] }` (unless all of the hashes clash)
Observed output: `{ "tokens": [<3 tokens>] }` (because the tokens are being placed into distinct buckets, and only a single hash can be drawn from each)

### Logs (if relevant)

_No response_
modules/analysis-common/src/test/java/org/elasticsearch/analysis/common/MinHashFilterFactoryTests.java
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0 and the Server Side Public License, v 1; you may not use this file except
 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */
package org.elasticsearch.analysis.common;
import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.core.WhitespaceTokenizer;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.env.Environment;
import org.elasticsearch.index.analysis.AnalysisTestsHelper;
import org.elasticsearch.index.analysis.TokenFilterFactory;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.test.ESTokenStreamTestCase;
import java.io.IOException;
import java.io.StringReader;
public class MinHashFilterFactoryTests extends ESTokenStreamTestCase {
    public void testDefault() throws IOException {
        int default_hash_count = 1;
        int default_bucket_size = 512;
        int default_hash_set_size = 1;