Manually setting custom attributes per edge / vertex / etc

To iterate on the other answer, you can access and edit attributes in edit mode, but you have to use the Bmesh API. One caveat is you can't use foreach_set and foreach_get so this might be slow on dense meshes. You have to loop over mesh elements (verts, edges, corner or faces) and for each element, access the layer.

Same thing as @Linus' answer but in edit mode :

import bpy
import bmesh

mesh = bpy.data.objects["Cube"].data
attribute = mesh.attributes.new(name="new attribute", type="FLOAT", domain="POINT")
attribute_values = [i for i in range(len(mesh.vertices))]

bm = bmesh.from_edit_mesh(mesh)
layer = bm.verts.layers.float.get(attribute.name)

for vert in bm.verts:
    print(f"Previous value for {vert} : {vert[layer]}")
    vert[layer] = attribute_values[vert.index]
    print(f"New value for {vert} : {vert[layer]}")

bmesh.update_edit_mesh(mesh)

https://docs.blender.org/api/current/bmesh.types.html#bmesh.types.BMLayerAccessVert

But as best as I can tell, these named custom attributes exist only as locations to which geometry nodes can write procedurally calculated intermediate values

Attributes do not have be procedurally calculated. If you do not want an attribute to be a calculation of something else, assign it a constant value; if you want it to be calculated only from static values, calculate it only from static values:

Both "ind" and "zero" are now attributes on the mesh.

If your attributes are not going to be recalculated, you can store them by applying the modifier:

After applying the modifier, these attributes remain stored as mesh data, and continue to work in other geometry nodes modifiers:

possible to define custom attributes associated with vertices or edges of a mesh and then assign values to them manually as part of the mesh creation process

I can't conceive of any definitions where creating modifiers and applying them is not part the manual mesh creation process-- just like a lot of my characters have a live mirror modifier until late in the mesh creation process, and then I apply it.

What can be tricky is assigning attributes their values in an intuitive way, but what's intuitive depends on what kind of data those attributes are, and how they're going to be used. Thankfully, there are a huge variety of ways to assign data, of various types, which can be converted into attributes.

For 1D vertex data, we can use the existing tools to set vertex weight. If we want attributes outside of the 0,1 range, we can map the desired range into the 0,1 range (mentally perhaps), assign vertex group weights, and then map back into the attribute range in the GN modifier (the one that we apply, or the one that reads those "written" attributes, either will work.)

For 2D vertex or face corner data, we can use UV. For 3D or 4D vertex or face corner data, we can use vertex color. For 3D data that is easiest to visualize as position, we can set this by transferring the attribute, by index, from an edited copy of the mesh. For edge data, we might use edge_crease as an input to our GN-- there should be others that work, but quick testing guarantees that one works. For face data, we can use any face-corner data cast to face data.

And if some technique is intuitive, but it's the wrong dimensionality, we can ignore some channels; and if we want more dimensions, we can use more instances of that data. We can use 2 UV maps or 4 vertex groups to specify 4D attributes, for example.

Do any of these collide with other uses of that data? Let's say you want to write some edge data to the mesh, a mesh which is already using edge_crease. No problem: write the current edge crease data to a new attribute, and you can restore it when you're done writing the other edge crease data. Using attributes, any limits regarding the number of edge_crease "channels" nearly disappear. (Also true for UV and vertex color, mesh data where Blender's limits can be relevant even without the use of GN.)

So not only can we set attributes manually, we can "paint" them using almost any of Blender's tools for painting data, often interchangeably.