[Feat] Expose any tuple from cache C impl

[haochengxia]

• Expose one function inner cache impl, dump to export tuples from C to Python, current design is：

  // C code
  typedef struct {
   ValueType type;
   union {
   int i;
   double d;
   const char* s;
   void* ptr;
   } data;
  } AnyValue;
  
  typedef struct {
   AnyValue* items;
   size_t size;
  } C_Tuple_Like;
  
  C_Tuple_Like* make_sample_tuple() {
   C_Tuple_Like* tuple = malloc(sizeof(C_Tuple_Like));
   tuple->size = 3;
   tuple->items = malloc(sizeof(AnyValue) * 3);
   tuple->items[0] = (AnyValue){ .type = TYPE_INT, .data.i = 42 };
   tuple->items[1] = (AnyValue){ .type = TYPE_DOUBLE, .data.d = 3.14 };
   tuple->items[2] = (AnyValue){ .type = TYPE_STRING, .data.s = strdup("hello") };
   return tuple;
  }
  
  // C++ code
  std::tuple<int, double, std::string> convert(const C_Tuple_Like* ctuple);
  
  std::tuple<int, double, std::string> convert_to_tuple(const C_Tuple_Like* input) {
   int i = input->items[0].data.i;
   double d = input->items[1].data.d;
   std::string s = input->items[2].data.s;
   return std::make_tuple(i, d, s);
  }
  
  // To Python
  py::tuple convert_to_py_tuple(const C_Tuple_Like* input) {
   py::tuple result(input->size);
   for (size_t i = 0; i < input->size; ++i) {
   const auto& item = input->items[i];
   switch (item.type) {
   case TYPE_INT:
   result[i] = py::int_(item.data.i);
   break;
   case TYPE_DOUBLE:
   result[i] = py::float_(item.data.d);
   break;
   case TYPE_STRING:
   result[i] = py::str(item.data.s);
   break;
   default:
   result[i] = py::none(); // fallback
   }
   }
   return result;
  }
  
  m.def("get_tuple", []() {
   C_Tuple_Like* c_tuple = make_sample_tuple();
   auto py_tuple = convert_to_py_tuple(c_tuple);
   // free if needed
   return py_tuple;
  });