fix(pine-cpp): explicitly delete RowFrame / ColumnFrame copy & move (#135 review)

Address bot-reviewer concern on the previous PR commits: switching mu_
from `std::shared_mutex` to `shared_ptr<std::shared_mutex>` removed
the implicit non-copyable/non-movable guarantee that the inline
shared_mutex member used to provide. Every other RowFrame member is
copyable, so post-migration RowFrame became implicitly
copy/move-constructible. A value copy would have aliased the mutex
(shared_ptr copy) while deep-copying items_ — two "independent"
frames sharing one lock for unrelated data, exactly the kind of
subtle hazard #103 was about preventing.

ColumnFrame stayed non-copyable through its `unique_ptr<ColumnStore>`,
producing the asymmetry the reviewer flagged.

Fix: explicitly delete copy/move ctors and assignments on both
RowFrame and ColumnFrame. RowFrame restores the lost invariant;
ColumnFrame pins the implicit one explicitly so the contract is
self-describing rather than depending on a future reader noticing
the unique_ptr member.

No call site copies or moves either Frame in the current tree; this
commit is purely about preventing future misuse. Test suite still
passes (213/213, 110k+ assertions) — no value-copy paths existed to
break.

Refs #103, #135.

Author: Liam0205

pine-cpp/include/pine/column_frame.hpp

@@ -31,6 +31,14 @@ class ColumnFrame : public Frame {
   ColumnFrame();
   ColumnFrame(Variant::object_t common, std::vector<Variant::object_t> items);
 
+  // Non-copyable, non-movable. unique_ptr<ColumnStore> already enforces
+  // this implicitly, but pin it explicitly to mirror RowFrame's
+  // post-#103 declaration and keep the contract self-describing.
+  ColumnFrame(const ColumnFrame&) = delete;
+  ColumnFrame& operator=(const ColumnFrame&) = delete;
+  ColumnFrame(ColumnFrame&&) = delete;
+  ColumnFrame& operator=(ColumnFrame&&) = delete;
+
   // Static convenience constructor kept for callers that already know
   // they want a ColumnFrame window view. parallel_execute uses the
   // virtual Frame::make_window_view on the parent — this static form

pine-cpp/include/pine/row_frame.hpp

@@ -28,6 +28,20 @@ class RowFrame : public Frame {
   RowFrame();
   RowFrame(Variant::object_t common, std::vector<Variant::object_t> items);
 
+  // Non-copyable, non-movable. Pre-#103 this was implicit (the inline
+  // std::shared_mutex member was itself neither copyable nor movable);
+  // after the migration to shared_ptr<shared_mutex> the implicit
+  // protection was lost — every other member is copyable, so RowFrame
+  // would have become copy/move-constructible. A value copy would alias
+  // the mutex (shared_ptr copy) but deep-copy items_ storage, leaving
+  // two "independent" frames sharing one lock for unrelated data.
+  // ColumnFrame stays non-copyable via its unique_ptr<ColumnStore>; we
+  // pin RowFrame the same way explicitly to keep the symmetry.
+  RowFrame(const RowFrame&) = delete;
+  RowFrame& operator=(const RowFrame&) = delete;
+  RowFrame(RowFrame&&) = delete;
+  RowFrame& operator=(RowFrame&&) = delete;
+
   // ---- Frame interface ----
   Variant common(const std::string& field) const override;
   bool has_common(const std::string& field) const override;