This PR removes __dict__ and @cached_property from Cell, This is in line with #3108 and reduces the memory footprint of a grid. This works because only @cached_property requires Cell.__dict__. Properties, descriptors, but also @cache don't need Cell.__dict__, because they rely on storage at the class-level, not the instance-level.

Motivation for removing __dict__
As indicated by @falloficarus22 in #3108,

Mesa environments often consist of millions of cells. Previously, the Cell class included __dict__ in its__slots__, which resulted in an overhead of approximately 300 bytes per instance (due to the presence of an empty dictionary). For high-resolution grids (e.g., 1000x1000), this contributed ~300MB of unnecessary RAM usage. This bottleneck limited the scalability of complex spatial models.

It also replaces the PropertyDescriptor with a property factory pattern, as suggested by @codebreaker32 in #3080. But, I still need to include the cell.empty read-only content from #3080.

1. What are the performance implications of this?

So far, it appears that there is a slight performance loss from removing @cached_property. This is largely due to the extra method call from the property to get_neighborhood, which is still cached. Shifting from self.cell.neighborhood to self.cell.get_neighborhood() avoids the indirection, which has a small performance benefit. For Mesa 4.0, we may consider removing cell.neighborhood, as we currently have two different ways of obtaining a neighborhood with a radius of 1 and the center excluded.

Shifting from a descriptor to a property halves the time to access it. There might be room for further improvement here.

2. cell.empty in main works because of Grid adding a property layer. However, as per Enforce read-only safety for 'empty' layer #3080, empty is a bit of a weird case. Cell.empty is special. The cell itself should be able to write to it, but the user should not be able to. One option is to rename it to _empty to clearly signal that it is used internally and should be left alone by the user. In which case, we can still use property layers. Another option is to avoid using self.add_property_layer and instead work around it for empty.

Regardless, a benefit of shifting from a descriptor to a property factory is that write-only access becomes trivial. The property() function takes as keyword arguments a getter, a setter, and a deleter. By omitting the setter, you have automatically created read-only access.