=act reimplement actor path validation without regex

While working on fixing https://github.com/akka/akka/pull/16347 I decided to let go of the regexp and impl simpler methods.

I found that on a smaller scale the new methods are way better, but in the grand scheme of things there seems to be a larger trade off at higher percentiles.

I got to:

```
+[info] a.a.ActorCreationBenchmark.synchronousStarting       ss     20000       16.413        1.494       us
```

from an initial:

```
+[info] a.a.ActorCreationBenchmark.synchronousStarting       ss     20000       27.022        1.903       us
```

but the higher percentiles got hit quite hard (*averages mean nothing* mantra kicks in...).

Note: These implementations pass tests in akka actor and survive the `...|%67` which caused the regex based impl to blow up.

Do you think it is worth trying one of these impls or am I on the wrong way?
So the highest percentiles look not pretty bad here, suspected some gc action. I've re run the benchmarks against old and new new - with 30 forks each. The old impl also got these spikes sometimes:

```
// OLD, worst case of 30 forks
[info] Result: 31.896 ±(99.9%) 7.961 us [Average]
[info]   Statistics: (min, avg, max) = (13.000, 31.896, 9665.000), stdev = 152.899
[info]   Confidence interval (99.9%): [23.935, 39.857]
[info]   Samples, N = 4000
[info]         mean =     31.896 ±(99.9%) 7.961 us
[info]          min =     13.000 us
[info]   p( 0.0000) =     13.000 us
[info]   p(50.0000) =     27.000 us
[info]   p(90.0000) =     42.000 us
[info]   p(95.0000) =     52.000 us
[info]   p(99.0000) =     80.990 us
[info]   p(99.9000) =    159.991 us
[info]   p(99.9900) =   9665.000 us
[info]   p(99.9990) =   9665.000 us
[info]   p(99.9999) =   9665.000 us
[info]          max =   9665.000 us
```

usually (from these 30 runs) 99.999 are between 200 and 1000, these 7000/9000 I'd blame noise for.

End result of **old**:
```
[info] a.a.ActorCreationBenchmark.synchronousStarting       ss    120000       28.285        0.481       us
```

the new ends up at:

```
[info] a.a.ActorCreationBenchmark.synchronousStarting       ss    120000       21.496        0.502       us
```

So it's in general faster, and has the same hickups as the old one had (some 99.999 percentiles went up to 7k etc).
So this characteristic didn't change, we did beat some micros on the path checking though.