Renamed inserter to __appender, moved functions into concat_impl name…

…space

For open-source SYCL bundle based on clang 17.0 and using GCC 10.2 toolchain
compilation error about ambiguous call to inserter was encountered. This was
because of name clash between the definition in this file and std::inserter.

Renaming helped resolve that.

Thank you @ZzEeKkAa for reportign this issue.

dpctl/tensor/libtensor/source/boolean_advanced_indexing.cpp

@@ -44,36 +44,44 @@ namespace tensor
 namespace py_internal
 {
 
+namespace concat_impl
+{
+
 struct sink_t
 {
     sink_t(){};
     template <class T> sink_t(T &&){};
 };
 
-template <class V> std::size_t accumulate_size(std::size_t &s, V &&v)
+template <class V> std::size_t __accumulate_size(std::size_t &s, V &&v)
 {
     return s += v.size();
 }
 
-template <class V, class U> sink_t inserter(V &lhs, U &&rhs)
+template <class V, class U> sink_t __appender(V &lhs, U &&rhs)
 {
     lhs.insert(lhs.end(), rhs.begin(), rhs.end());
     return {};
 }
 
+} // namespace concat_impl
+
 template <typename T, typename A, typename... Vs>
 std::vector<T, A> concat(std::vector<T, A> lhs, Vs &&...vs)
 {
+    using concat_impl::__accumulate_size;
+    using concat_impl::__appender;
+    using concat_impl::sink_t;
     std::size_t s = lhs.size();
     {
         // limited scope ensures array is freed
-        [[maybe_unused]] sink_t tmp[] = {accumulate_size(s, vs)..., 0};
+        [[maybe_unused]] sink_t tmp[] = {__accumulate_size(s, vs)..., 0};
     }
     lhs.reserve(s);
     {
-        // array of no-data objects ensures ordering of calls to inserter
-        [[maybe_unused]] sink_t tmp[] = {inserter(lhs, std::forward<Vs>(vs))...,
-                                         0};
+        // array of no-data objects ensures ordering of calls to the appender
+        [[maybe_unused]] sink_t tmp[] = {
+            __appender(lhs, std::forward<Vs>(vs))..., 0};
     }
 
     return std::move(lhs); // prevent return-value optimization