[FEA] Introduce a new owning type for Arrow interop data about cudf HOT 7 OPEN

std::unique_ptr<cudf::arrow_column> from_arrow(ArrowSchema const* schema, ArrowDeviceArray *input, rmm::cuda_stream_view stream, rmm::mr::device_memory_resource mr);

class arrow_column {
  arrow_column(ArrowDeviceArray *input) {
    ArrowArrayMove(input, arr.get());
  }
  ~arrow_column() {
    arr.release();
  }
  column_view view();
  mutable_column_view mutable_view();
private:
  // Using a shared_ptr to potentially allow re-export in the future, but that would require extra machinery to get right.
  std::shared_ptr<ArrowDeviceArray> arr;
}

// Class to manage lifetime semantics and allow re-export.
struct arrow_array_container {
  ArrowDeviceArray* arr;
  // Question: When the input data was host data, we could presumably release
  // immediately. Do we care? If so, how should we implement that?
  ~arrow_array_container() {
    arr->array.release(&arr->array);
  }
};

class arrow_column {
public:
  arrow_column(ArrowDeviceArray *input) {
    ArrowArrayMove(input, container->arr);
  }
  cudf::column_view view();
  cudf::mutable_column_view mutable_view();

  // Create Array whose private_data contains a shared_ptr to this->container
  // The output should be consumer-allocated, see
  // https://arrow.apache.org/docs/format/CDataInterface.html#member-allocation
  // Note: May need stream/mr depending on where we put what logic.
  void to_arrow(ArrowDeviceArray *output);
private:
  // Using a shared_ptr allows re-export via to_arrow
  std::shared_ptr<arrow_array_container> container;
};

class arrow_table {
public:
  arrow_table(std::vector<std::shared_ptr<arrow_column> columns) : columns{columns} {}
  cudf::table_view view();
  cudf::mutable_table_view mutable_view();
  // Create Array whose private_data contains shared_ptrs to all the underlying arrow_array_containers
  void to_arrow(ArrowDeviceArray *output);
private:
  // Would allow arrow_columns being in multiple arrow_tables
  std::vector<std::shared_ptr<arrow_column> columns;
};

// ArrowArrayStream and ArrowArray overloads (they can be overloads now instead
// of separate functions) are trivial wrappers around this function. Also need versions
// of all three that return an arrow_column instead of an arrow_table.
std::unique_ptr<arrow_table> from_arrow(
  ArrowSchema const* schema,
  ArrowDeviceArray *input,
  rmm::cuda_stream_view stream,
  rmm::mr::device_memory_resource mr);

// Produce an ArrowDeviceArray and then create an arrow_column around it.
std::unique_ptr<arrow_table> to_arrow(
  // Question: Do we really need a column_view overload? If we're going this
  // route, I think it's OK to always require a transfer of ownership to the
  // arrow_table, but there is potentially some small overhead there.
  std::unique_ptr<cudf::table> input,
  rmm::cuda_stream_view stream      = cudf::get_default_stream(),
  rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());