### Elasticsearch Version

8.6.0

### Installed Plugins

_No response_

### Java Version

_bundled_ (Elastic Cloud)

### OS Version

N/A (Elastic Cloud)

### Problem Description

The Elasticsearch's JSON Processor is not producing errors when dealing with texts that starts with integers (in general, strings that match the regular expression `/\d+(\s+.*)?/`). In these cases, instead of producing errors, the JSON Processor parses as a integer number the first number encountered. Some examples:

| INPUT  | OUTPUT |
| ------------- | ------------- |
| `"0"`    | `0` |
| `"123 foo"`  | `123`  |
| `"45 this is {\"a\": \"json\"}"`  | `45` |


### Steps to Reproduce

To reproduce the bug we can create a pipeline that only contains the JSON-Processor:

```json
PUT _ingest/pipeline/test-json
{
  "processors": [
    {
      "json": {
        "field": "message",
        "target_field": "test"
      }
    }
  ]
}
```

And simulate the result with the following body (in the table other examples are shown):

```json
GET _ingest/pipeline/test-json/_simulate
{
  "docs": [
    {
      "_source": {
        "message":"0"
      }
    }
  ]
}
```
The result is the following one:

```json
{
  "docs": [
    {
      "doc": {
        "_index": "_index",
        "_id": "_id",
        "_version": "-3",
        "_source": {
          "message": "0",
          "test": 0
        },
        "_ingest": {
          "timestamp": "2023-01-13T08:31:49.758255214Z"
        }
      }
    }
  ]
```

Note that `test` (i.e., the `target_field`) contains an integer and the JSON-Processor did not produced an error. This behavior is unexpected and can lead to documents to not be indexed because `target_field` is of type long instead of Object.



### Logs (if relevant)

_No response_
modules/ingest-common/src/main/java/org/elasticsearch/ingest/common/Processors.java
/**
     * Uses {@link BytesProcessor} to return the number of bytes in a
     * human-readable byte string such as <code>1kb</code>.
     *
     * @param value human-readable byte string
     * @return number of bytes
     */
    public static long bytes(String value) {
        return BytesProcessor.apply(value);
    }
    /**
     * Uses {@link LowercaseProcessor} to convert a string to its lowercase
     * equivalent.
     *
     * @param value string to convert
     * @return lowercase equivalent
     */
    public static String lowercase(String value) {
        return LowercaseProcessor.apply(value);
    }
    /**
     * Uses {@link UppercaseProcessor} to convert a string to its uppercase
     * equivalent.