Do not treat std::array as implicitly reflectable (#169)

[DuminAndrew]

Problem

boost::pfr::is_implicitly_reflectable_v<std::array<T, N>> evaluates to true
because std::array is an aggregate. But std::array keeps its elements in a
single C array data member, which Boost.PFR can not reflect correctly yet
(#20) — tuple size and per-field access are wrong. Since downstream adaptors
use is_reflectable / is_implicitly_reflectable to decide whether to route a
type through PFR, the trait reporting true makes them mis-handle std::array.

This is the explicit request in #169.

Change

• Add a detail::is_stdarray trait.
• Exclude std::array from the implicit reflection branch in
  detail/possible_reflectable.hpp, both with and without
  __cpp_lib_is_aggregate.

The change only affects the is_implicitly_reflectable decision; ordinary
aggregates are unaffected, and no public API is added or removed.

Tests

Extended test/core/run/is_implicitly_reflectable.cpp to assert that
std::array (and its cv-qualified forms) is non-reflectable for both the
boost_json_tag and boost_fusion_tag tags, while plain aggregates stay
reflectable.

Verified locally with g++ 15.2 at cxxstd=14/17/20; the existing
is_reflectable, is_implicitly_reflectable, and tuple_size run-tests
continue to pass.

Closes #169.

[apolukhin]

The workaround is too specific... How about treating all the types with name array (std::array, boost::array, ...) as non reflectable?

This could be done in the following way:

template <class T>
constexpr std::false_type is_array(int);

template <class T>
constexpr auto is_array(long) -> decltype(std::declval<T>().~array(), std::true_type{});

Call it as decltype(detail::is_array<T>(1L))::value

That way there's no need to include <array> and it would work with boost::array too