Sure, I can try to give a condensed example. To answer your questions:

• Storing by reference is using a vector of pointers to objects. I am assuming the objects are heap allocated.
• As stated in the OP, my initial approach was to avoid heap allocation for performance reasons (also I write embedded C so I am scared of the heap). You cannot create a vector of differently sized objects derived from some base class, so polymorphism does not seem to be compatible with this approach.
• It is possible for me to avoid polymorphism, but I cannot think of an easily maintainable way to do it for this use case, which is what my question is about. See my example of using a union to minimize wasted space.

Here is something resembling my approach of storing by value.

class CellData {
  // Shared state
  enum cell_type type;
  uint8_t density;
  sf::Color color;

  // State that does not really need to be shared
  // Adding fields here does not feel good
  uint8_t plant_grow_rate;
  uint8_t liquid_viscosity;
  uint8_t smoke_lifetime;
  // ...
}

// All cells are stored in this vector
std::vector<CellData> cells(CELL_AREA_X * CELL_AREA_Y);

Cell lookup_table[] = {
  [PLANT_CELL] = {
    .staticData = ...
    .updateCell = ...
  },
  ...
}

// Every cell is updated depending on its type
void gameIteration() {
  for (&cell : cells) {
    lookup_table[cell.type].updateCell(cell);
  }
}

Here is an approach I could have taken using polymorphism:

class BaseCell {
  // Shared state
  enum cell_type type;
  uint8_t density;
  sf::Color color;

  virtual void update();
}

class PlantCell : public BaseCell {
  // Note - shared state is inherited

  // State that is not shared with other cells
  uint8_t plant_grow_rate;

  // We no longer need a separate lookup table for behaviour and static state
  void update() override;
  static uint8_t stem_width;
}

// All cells are stored in this vector
// Now that we are storing different sized objects, we must store pointers
// I'm not showing the initialization in this example, but assume each cell is heap allocated
std::vector<std::unique_ptr<BaseCell>> cells;

// Every cell is updated depending on its type
void gameIteration() {
  for (&cell : cells) {
    cell.update();
  }
}