[analyzer] Improve handling of placement new in `PointerArith` (#155855)

This pull improves the handling of placement new in`PointerArith`,
fixing one family of false positives, and one of negatives:

### False Positives

```cpp
  Buffer buffer;
  int* array = new (&buffer) int[10];
  ++array; // there should be no warning
```

The code above should flag the memory region `buffer` as reinterpreted,
very much as `reinterpret_cast` would do. Note that in this particular
case the placement new is inlined so the engine can track that `*array`
points to the same region as `buffer`.

This is no-op if the placement new is opaque.

### False Negatives

```cpp
  Buffer buffer;
  int* array = new (&buffer) int;
  ++array; // there should be a warning
```

In this case, there is an implicit cast to `void*` when calling
placement new. The memory region was marked as reinterpreted, and
therefore later pointer arithmetic will not raise. I have added a
condition to not consider a cast to `void*` as a reinterpretation, as an
array of voids does not make much sense.


There are still some limitations, of course. For starters, if a single
`int` is created in place of an array of `unsigned char` of exactly the
same size, it will still be considered as an array. A convoluted example
to make the point that I think it makes sense *not* to raise in this
situation is in the test `checkPlacementNewSlices`.

CPP-6868