fix: Preserve nullable and unique modifiers in describe() for FK attributes

The describe() method now correctly outputs FK options like [nullable],
[unique], or [nullable, unique] by:

1. Checking if any FK attribute has nullable=True in the heading
2. Combining nullable with existing index properties (unique, etc.)
3. Formatting all options into a single bracket notation

This fixes the round-trip issue where describe() output could not be
used to recreate an equivalent table definition.

Fixes: describe() tests that verify definition round-trips

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/table.py

@@ -1100,25 +1100,38 @@ def describe(self, context=None, printout=False):
                 if attr.name in fk_props["attr_map"]:
                     do_include = False
                     if attributes_thus_far.issuperset(fk_props["attr_map"]):
-                        # foreign key properties
+                        # foreign key properties - collect all options
+                        fk_options = []
+
+                        # Check if FK is nullable (any FK attribute has nullable=True)
+                        is_nullable = any(
+                            self.heading.attributes[attr_name].nullable
+                            for attr_name in fk_props["attr_map"]
+                        )
+                        if is_nullable:
+                            fk_options.append("nullable")
+
+                        # Check for index properties (unique, etc.)
                         try:
                             index_props = indexes.pop(tuple(fk_props["attr_map"]))
                         except KeyError:
-                            index_props = ""
+                            pass
                         else:
-                            index_props = [k for k, v in index_props.items() if v]
-                            index_props = " [{}]".format(", ".join(index_props)) if index_props else ""
+                            fk_options.extend(k for k, v in index_props.items() if v)
+
+                        # Format options as " [opt1, opt2]" or empty string
+                        options_str = " [{}]".format(", ".join(fk_options)) if fk_options else ""
 
                         if not fk_props["aliased"]:
                             # simple foreign key
-                            definition += "->{props} {class_name}\n".format(
-                                props=index_props,
+                            definition += "->{options} {class_name}\n".format(
+                                options=options_str,
                                 class_name=lookup_class_name(parent_name, context) or parent_name,
                             )
                         else:
                             # projected foreign key
-                            definition += "->{props} {class_name}.proj({proj_list})\n".format(
-                                props=index_props,
+                            definition += "->{options} {class_name}.proj({proj_list})\n".format(
+                                options=options_str,
                                 class_name=lookup_class_name(parent_name, context) or parent_name,
                                 proj_list=",".join(
                                     '{}="{}"'.format(attr, ref) for attr, ref in fk_props["attr_map"].items() if ref != attr