**Describe the bug**

JSONExtract returns 0 for numbers with floating-point for type *float / Float32*.

**How to reproduce**

```sql
WITH '{ "v":1.1}' AS raw
SELECT 
    JSONExtract(raw, 'v', 'float') AS float32_1,
    JSONExtract(raw, 'v', 'Float32') AS float32_2,
    JSONExtractFloat(raw, 'v') AS float64_1,
    JSONExtract(raw, 'v', 'double') AS float64_2

/*
┌─float32_1─┬─float32_2─┬─float64_1─┬─float64_2─┐
│         0 │         0 │       1.1 │       1.1 │
└───────────┴───────────┴───────────┴───────────┘
*/
```

```sql
WITH '{ "v":1E-2}' AS raw
SELECT 
    JSONExtract(raw, 'v', 'float') AS float32_1,
    JSONExtract(raw, 'v', 'Float32') AS float32_2,
    JSONExtractFloat(raw, 'v') AS float64_1,
    JSONExtract(raw, 'v', 'double') AS float64_2

/*
┌─float32_1─┬─float32_2─┬─float64_1─┬─float64_2─┐
│         0 │         0 │      0.01 │      0.01 │
└───────────┴───────────┴───────────┴───────────┘
*/
```

**Expected behavior**

I think either need to add support *float / Float32* type or throw an exception to point to need to use *double / Float64* type.

**Additional context**
CH v. 20.6.4.44

{
                            if (nested[index->second]->insertResultToColumn(tuple.getColumn(index->second), value))
                                were_valid_elements = true;
                        }
                    }
                }
                set_size(old_size + static_cast<size_t>(were_valid_elements));
                return were_valid_elements;
            }
            return false;
        }
    private:
        std::vector<std::unique_ptr<Node>> nested;
        std::vector<String> explicit_names;
        std::unordered_map<std::string_view, size_t> name_to_index_map;
    };
    static std::unique_ptr<Node> build(const char * function_name, const DataTypePtr & type)
    {
        switch (type->getTypeId())
        {
            case TypeIndex::UInt8: return std::make_unique<NumericNode<UInt8>>();
            case TypeIndex::UInt16: return std::make_unique<NumericNode<UInt16>>();
            case TypeIndex::UInt32: return std::make_unique<NumericNode<UInt32>>();
            case TypeIndex::UInt64: return std::make_unique<NumericNode<UInt64>>();
            case TypeIndex::Int8: return std::make_unique<NumericNode<Int8>>();
            case TypeIndex::Int16: return std::make_unique<NumericNode<Int16>>();
            case TypeIndex::Int32: return std::make_unique<NumericNode<Int32>>();
            case TypeIndex::Int64: return std::make_unique<NumericNode<Int64>>();
            case TypeIndex::Float32: return std::make_unique<NumericNode<Float32>>();
            case TypeIndex::Float64: return std::make_unique<NumericNode<Float64>>();